indigo

type Any struct{}

type Bool struct{}

type CompilationOption func(f *compileOptions)

type Compiler interface {
	Compile(r *Rule, opts ...CompilationOption) error
}

type DataElement struct {
	// Short, user-friendly name of the variable. This is the name
	// that will be used in rules to refer to data passed in.
	//
	// RESERVED NAMES:
	//   selfKey (see const)
	Name string `json:"name"`

	// One of the Type interface defined.
	Type Type `json:"type"`

	// Optional description of the type.
	Description string `json:"description"`
}

type DefaultEngine struct {
	// contains filtered or unexported fields
}

type Diagnostics struct {
	Expr      string // the part of the rule expression evaluated
	Interface any
	Source    ValueSource   // where the value came from: input data, or evaluted by the engine
	Line      int           // the 1-based line number in the original source expression
	Column    int           // the 0-based column number in the original source expression
	Offset    int           // the 0-based character offset from the start of the original source expression
	Children  []Diagnostics // one child per sub-expression. Each Evaluator may produce different results.
}

type Duration struct{}

type Engine interface {
	Compiler
	Evaluator
}

type EvalOption func(f *EvalOptions)

type EvalOptions struct {
	// TrueIfAny makes a parent rule Pass = true if any of its child rules are true.
	// The default behavior is that a rule is only true if all of its child rules are true, and
	// the parent rule itself is true.
	// Setting TrueIfAny changes this behvior so that the parent rule is true if at least one of its child rules
	// are true, and the parent rule itself is true.
	TrueIfAny bool `json:"true_if_any"`

	// StopIfParentNegative prevents the evaluation of child rules if the parent's expression is false.
	// Use case: apply a "global" rule to all the child rules.
	StopIfParentNegative bool `json:"stop_if_parent_negative"`

	// Stops the evaluation of child rules when the first positive child is encountered.
	// Results will be partial. Only the child rules that were evaluated will be in the results.
	// Use case: role-based access; allow action if any child rule (permission rule) allows it.
	StopFirstPositiveChild bool `json:"stop_first_positive_child"`

	// Stops the evaluation of child rules when the first negative child is encountered.
	// Results will be partial. Only the child rules that were evaluated will be in the results.
	// Use case: you require ALL child rules to be satisfied.
	StopFirstNegativeChild bool `json:"stop_first_negative_child"`

	// Do not return rules that passed
	// Default: all rules are returned
	DiscardPass bool `json:"discard_pass"`

	// Decide what to do to rules that failed
	// Default: all rules are returned
	DiscardFail FailAction

	// Include diagnostic information with the results.
	// To enable this option, you must first turn on diagnostic
	// collection at the engine level with the CollectDiagnostics EngineOption.
	ReturnDiagnostics bool `json:"return_diagnostics"`

	// Specify the function used to sort the child rules before evaluation.
	// Useful in scenarios where you are asking the engine to stop evaluating
	// after either the first negative or first positive child in order to
	// select a rule with some relative characteristic, such as the "highest
	// priority rule".
	//
	// See the ExampleSortFunc() for an example.
	// The function returns whether rules[i] < rules[j] for some attribute.
	// Default: No sort
	SortFunc func(rules []*Rule, i, j int) bool `json:"-"`

	// Parallel controls parallel evaluation of child rules with batching.
	Parallel ParallelConfig `json:"parallel"`
	// contains filtered or unexported fields
}

type Evaluator interface {
	Eval(ctx context.Context, r *Rule, d map[string]any, opts ...EvalOption) (*Result, error)
}

type ExpressionCompiler interface {
	Compile(expr string, s Schema, resultType Type, collectDiagnostics, dryRun bool) (any, error)
}

type ExpressionCompilerEvaluator interface {
	ExpressionCompiler
	ExpressionEvaluator
}

type ExpressionEvaluator interface {
	Evaluate(data map[string]any, expr string, s Schema,
		self any, evalData any, resultType Type, returnDiagnostics bool) (any, *Diagnostics, error)
}

type FailAction int

type Float struct{}

type Int struct{}

type List struct {
	ValueType Type // the type of element stored in the list
}

type Map struct {
	KeyType   Type // the type of the map key
	ValueType Type // the type of the value stored in the map
}

type Mutation struct {
	// contains filtered or unexported fields
}

type MutationStats struct {
	Added         int
	Moved         int
	Updated       int
	Deleted       int
	ChangedShards int
}

type ParallelConfig struct {
	BatchSize   int `json:"batch_size"`
	MaxParallel int `json:"max_parallel"`
}

type Proto struct {
	Message proto.Message // an instance of the proto message
}

type Result struct {
	// The Rule that was evaluated
	Rule *Rule

	// Whether the rule is true.
	// The default is TRUE.
	// Pass is the result of rolling up all child rules and evaluating the
	// rule's own expression. All child rules and the rule's expression must be
	// true for Pass to be true.
	Pass bool

	// Whether evaluating the rule expression yielded a TRUE logical value.
	// The default is TRUE.
	// The result will not be affected by the results of the child rules.
	// If no rule expression is supplied for a rule, the result will be TRUE.
	ExpressionPass bool

	// The raw result of evaluating the expression. Boolean for logical expressions.
	// Calculations, object constructions or string manipulations will return the appropriate Go type.
	// This value is never affected by child rules.
	Value any

	// Results of evaluating the child rules.
	Results map[string]*Result

	// Diagnostic data; only available if you turn on diagnostics for the evaluation
	Diagnostics *Diagnostics

	// The evaluation options used
	EvalOptions EvalOptions

	// A list of the rules evaluated, in the order they were evaluated
	// Only available if you turn on diagnostics for the evaluation
	// This may be different from the rules represented in Results, if
	// If we're discarding failed/passed rules, they will not be in the results,
	// and will not show up in diagnostics, but they will be in this list.
	RulesEvaluated []*Rule

	// Count of the number of rules whose expression was evaluated
	EvaluationCount int
}

type Rule struct {
	// A rule identifier. (required)
	ID string `json:"id"`

	// The expression to evaluate (optional)
	// The expression can return a boolean (true or false), or any
	// other value the underlying expression engine can produce.
	// All values are returned in the Results.Value field.
	// Boolean values are also returned in the results as Pass = true  / false
	// If the expression is blank, the result will be true.
	Expr string `json:"expr"`

	// The output type of the expression. Evaluators with the ability to check
	// whether an expression produces the desired output should return an error
	// if the expression does not.
	// If no type is provided, evaluation and compilation will default to Bool
	ResultType Type `json:"result_type,omitempty"`

	// The schema describing the data provided in the Evaluate input. (optional)
	// Some implementations of Evaluator require a schema.
	Schema Schema `json:"schema,omitempty"`

	// A set of child rules.
	Rules map[string]*Rule `json:"rules,omitempty"`

	// Reference to intermediate compilation / evaluation data.
	Program any `json:"-"`

	// A reference to any object.
	// Not used by the rules engine.
	Meta any `json:"-"`

	// A reference to an object whose values can be used in the rule expression.
	// Add the corresponding object in the data with the reserved key name selfKey
	// (see constants).
	// Child rules do not inherit the self value.
	Self any `json:"-"`

	// Options determining how the child rules should be handled.
	EvalOptions EvalOptions `json:"eval_options"`

	// Shards is a list of rules that define a sharding strategy for the rule's children.
	// If a rule has many rules, and some of them share a common characteristic, such as applying to
	// cars registered in specific states, or to students in a particular status, the child rules can be
	// grouped into a set of "shards", where all the children share the grouping criteria. For example,
	// if you have 1000 rules that apply only to students in the "Admitted"  status and 600 rules that apply only to
	// students in the "Enrolled" status, you can create two shards, one for each of the statuses. By calling
	// BuildShards on the rule, the child rules will be re-arranged into shards using the rules you provided.
	// See the shard tests and the [BuildShards] function for more information.
	Shards []*Rule
	// contains filtered or unexported fields
}

type Schema struct {
	// Identifier for the schema. Useful for the hosting application; not used by Indigo internally.
	ID string `json:"id,omitempty"`
	// User-friendly name for the schema
	Name string `json:"name,omitempty"`
	// A user-friendly description of the schema
	Description string `json:"description,omitempty"`
	// User-defined value
	Meta any `json:"-"`
	// List of data elements supported by this schema
	Elements []DataElement `json:"elements,omitempty"`
}

type String struct{}

type Timestamp struct{}

type Type interface {
	// Implements the stringer interface
	String() string
}

type ValueSource int

type Vault struct {
	// contains filtered or unexported fields
}