stepfunction

var ChoiceOperatorArray []string

var ChoiceSetOperator = struct {
	And  string
	Not  string
	Or   string
	None string
}{
	And:  "And",
	Not:  "Not",
	Or:   "Or",
	None: "None",
}

var CompareCode = struct {
	GT  string
	GTE string
	EQ  string
	LT  string
	LTE string
}{
	GT:  "GT",
	GTE: "GTE",
	EQ:  "EQ",
	LT:  "LT",
	LTE: "LTE",
}

var CompareFuncs = map[string]func(current any, except any) bool{
	Operators.IsBoolean: func(current any, except any) bool {
		return IsBool(current) == except.(bool)
	},
	Operators.IsNull: func(current any, except any) bool {
		return IsNull(current) == except.(bool)
	},
	Operators.IsNumeric: func(current any, except any) bool {
		return IsNumeric(current) == except.(bool)
	},
	Operators.IsString: func(current any, except any) bool {
		return IsString(current) == except.(bool)
	},

	Operators.IsTimestamp: func(current any, except any) bool {
		return IsTimestamp(current) == except.(bool)
	},
	Operators.StringEquals: func(current any, except any) bool {
		return StringCompare(current, except, CompareCode.EQ)
	},
	Operators.StringLessThan: func(current any, except any) bool {
		return StringCompare(current, except, CompareCode.LT)
	},
	Operators.StringLessThanEquals: func(current any, except any) bool {
		return StringCompare(current, except, CompareCode.LTE)
	},
	Operators.StringGreaterThan: func(current any, except any) bool {
		return StringCompare(current, except, CompareCode.GT)
	},
	Operators.StringGreaterThanEquals: func(current any, except any) bool {
		return StringCompare(current, except, CompareCode.GTE)
	},

	Operators.NumericEquals: func(current any, except any) bool {
		return NumberCompare(current, except, CompareCode.EQ)
	},
	Operators.NumericLessThan: func(current any, except any) bool {
		return NumberCompare(current, except, CompareCode.LT)
	},
	Operators.NumericGreaterThan: func(current any, except any) bool {
		return NumberCompare(current, except, CompareCode.GT)
	},
	Operators.NumericLessThanEquals: func(current any, except any) bool {
		return NumberCompare(current, except, CompareCode.LTE)
	},
	Operators.NumericGreaterThanEquals: func(current any, except any) bool {
		return NumberCompare(current, except, CompareCode.GTE)
	},

	Operators.BooleanEquals: func(current any, except any) bool {
		return current.(bool) == except.(bool)
	},
}

var ExistFuncs = map[string]func(current bool, except bool) bool{
	Operators.IsPresent:     func(current bool, except bool) bool { return current == except },
	Operators.IsExist:       func(current bool, except bool) bool { return current == except },
	Operators.VariableExist: func(current bool, except bool) bool { return current == except },
}

var KeyVariable = "Variable"

var Operators = struct {
	// exist  is variable exist
	VariableExist string
	IsExist       string
	IsPresent     string
	// Bool  is boolean
	IsBoolean   string
	IsNull      string
	IsNumeric   string
	IsString    string
	IsTimestamp string
	// String compare
	StringEquals            string
	StringLessThan          string
	StringGreaterThan       string
	StringLessThanEquals    string
	StringGreaterThanEquals string
	// Numeric compare
	NumericEquals            string
	NumericLessThan          string
	NumericGreaterThan       string
	NumericLessThanEquals    string
	NumericGreaterThanEquals string
	NumericEqualsPath        string
	// bool compare
	BooleanEquals string
	// Path string
	BooleanEqualsPath string
	// Timestamp compare
	TimestampEquals            string
	TimestampLessThan          string
	TimestampGreaterThan       string
	TimestampLessThanEquals    string
	TimestampGreaterThanEquals string
}{

	VariableExist: "VariableExist",
	IsExist:       "IsExist",
	IsPresent:     "IsPresent",

	IsBoolean:   "IsBoolean",
	IsNull:      "IsNull",
	IsNumeric:   "IsNumeric",
	IsString:    "IsString",
	IsTimestamp: "IsTimestamp",

	StringEquals:            "StringEquals",
	StringLessThan:          "StringLessThan",
	StringGreaterThan:       "StringGreaterThan",
	StringLessThanEquals:    "StringLessThanEquals",
	StringGreaterThanEquals: "StringGreaterThanEquals",

	NumericEquals:            "NumericEquals",
	NumericLessThan:          "NumericLessThan",
	NumericGreaterThan:       "NumericGreaterThan",
	NumericLessThanEquals:    "NumericLessThanEquals",
	NumericGreaterThanEquals: "NumericGreaterThanEquals",
	NumericEqualsPath:        "NumericEqualsPath",

	BooleanEquals: "BooleanEquals",

	BooleanEqualsPath: "BooleanEqualsPath",

	TimestampEquals:            "TimestampEquals",
	TimestampLessThan:          "TimestampLessThan",
	TimestampGreaterThan:       "TimestampGreaterThan",
	TimestampLessThanEquals:    "TimestampLessThanEquals",
	TimestampGreaterThanEquals: "TimestampGreaterThanEquals",
}