eval

type Array struct {
	Pos      value.Position
	Comments Comments
	Items    []Expression
}

type BuildOption struct {
	PositionalArgs []any
	Args           map[string]any
	Profiles       []string
}

type BuildOptions []BuildOption

type Call struct {
	Comments Comments
	Pos      value.Position
	Func     Expression
	Args     []Field
}

type Comments struct {
	Comments [][]string
}

type Default struct {
	Comments Comments
	Expr     Expression
	Pos      value.Position
}

type Embedded struct {
	Pos        value.Position
	Comments   Comments
	Expression Expression
}

type ErrInvalidArgument struct {
	Err error
}

type ErrKeyNotFound struct {
	Key     string
	Message string
	Err     error
}

type ErrUnknownError struct {
	Node ast.Node
}

type ErrorValue struct {
	value.Value
}

type EvalOption struct {
	Globals       map[string]any
	GlobalsLookup ScopeFunc
}

type EvalOptions []EvalOption

type Expression interface {
	ToValue(ctx context.Context) (value.Value, bool, error)
}

type Field interface {
	ToValueForIndex(ctx context.Context, idx int) (value.Value, bool, error)
	Position() value.Position

	// IsForLookup Should this field be added to the current scope and it's keys available as scope keys
	IsForLookup(ctx context.Context) bool
	// IsForValue Should this fields value be contributed to the rendered data
	IsForValue(ctx context.Context) bool
}

type FieldKey struct {
	Match         Expression
	Interpolation Expression
	Key           string
	Pos           value.Position
}

type File struct {
	PositionalArgs []any
	Args           map[string]any
	Profiles       []string
	Body           *Struct
}

type For struct {
	Comments   Comments
	Key        string
	Value      string
	Collection Expression
	Body       Expression
	Else       Expression
	Merge      bool
	Position   value.Position
}

type Function struct {
	Pos            value.Position
	Scope          Scope
	Body           Expression
	ReturnType     Expression
	ArgsSchema     value.Schema
	ArgNames       value.Names
	ProfilesSchema value.Schema
	ProfileNames   value.Names
	FuncSchema     *value.FuncSchema
	ReturnBody     bool
	AssignRoot     bool
	UnscopedArgs   bool
	// contains filtered or unexported fields
}

type FunctionDefinition struct {
	Comments   Comments
	Pos        value.Position
	Body       *Struct
	ReturnType Expression
	ReturnBody bool
	AssignRoot bool
}

type If struct {
	Pos       value.Position
	Comments  Comments
	Condition Expression
	Value     Expression
	Else      Expression
}

type Index struct {
	Comments Comments
	Pos      value.Position
	Base     Expression
	Index    Expression
}

type Interpolation struct {
	Parts []any
}

type IsArgumentDefinition interface {
	IsArgumentDefinition() bool
}

type IsPositionalArgument interface {
	IsPositionalArgument() bool
}

type KeyValue struct {
	Comments Comments
	Key      FieldKey
	Value    Expression
	Pos      value.Position
	Local    bool
	Optional bool
}

type LambdaDefinition struct {
	Comments Comments
	Pos      value.Position
	Vars     []string
	Body     Expression
}

type Lookup struct {
	Comments Comments
	Pos      value.Position
	Key      string
}

type LoopControl struct {
	Skip  bool
	Break bool
	Value value.Value
}

type NativeFunc func(context.Context, []value.Value) (value.Value, bool, error)

type Op struct {
	Unary    bool
	Comments Comments
	Operator value.Operator
	Left     Expression
	Right    Expression
	Pos      value.Position
}

type Parens struct {
	Comments Comments
	Expr     Expression
}

type Path []PathElement

type PathElement struct {
	Key   *string
	Index *int
	Call  bool
}

type Schema struct {
	Comments       Comments
	Expression     Expression
	AllowNewFields bool
}

type Scope interface {
	Depth() int
	IsRoot(ctx context.Context) (bool, error)
	Get(ctx context.Context, key string) (value.Value, bool, error)
	NewScope(ctx context.Context, data ScopeStorage) (Scope, context.Context)
}

type ScopeAsValue struct {
	Ctx   context.Context
	Scope Scope
}

type ScopeData map[string]any

type ScopeFunc func(ctx context.Context, key string, parent Scope) (value.Value, bool, error)

type ScopeStorage interface {
	Lookup(ctx context.Context, key string, parent Scope) (value.Value, bool, error)
}

type Selector struct {
	Comments Comments
	Pos      value.Position
	Base     Expression
	Key      Expression
}

type Slice struct {
	Comments Comments
	Pos      value.Position
	Base     Expression
	Start    Expression
	End      Expression
}

type Struct struct {
	Position value.Position
	Comments Comments
	Fields   []Field
}

type Value struct {
	Value value.Value
}

type ValueScopeLookup struct {
	Value value.Value
}