ast

type AggregateExpr struct {
	// FuncName is the name of the aggregate function (count, sum, min, max, mean, std, median).
	FuncName string
	// Var is the variable being aggregated.
	Var string
	// AttrName is the optional attribute name to aggregate on if the variable is a thing.
	AttrName string
}

type ArithmeticValue struct {
	// Left is the left operand (Value or variable string).
	Left any
	// Operator is the infix operator (+, -, *, /, %, ^).
	Operator string
	// Right is the right operand (Value or variable string).
	Right any
}

type AttributePattern struct {
	// Variable is the variable name for the attribute.
	Variable string
	// TypeName is the name of the attribute type.
	TypeName string
	// Value is the optional value of the attribute.
	Value Value
}

type Clause interface {
	QueryNode
	// contains filtered or unexported methods
}

type Compiler struct{}

type Constraint interface {
	QueryNode
	// contains filtered or unexported methods
}

type DeleteArtifactOptions struct {
	VarName string
	IDAttr  string
	Matcher IdentifierMatcher
}

type DeleteClause struct {
	// Statements are the statements defining what to delete.
	Statements []Statement
}

type DeleteHasStatement struct {
	// AttrVar is the variable representing the attribute to delete (e.g., "$old").
	AttrVar string
	// OwnerVar is the variable representing the owner entity/relation (e.g., "$e").
	OwnerVar string
}

type DeleteThingStatement struct {
	// Variable is the variable representing the thing to delete.
	Variable string
}

type EntityPattern struct {
	// Variable is the variable name for the matched entity.
	Variable string
	// TypeName is the name of the entity type.
	TypeName string
	// Constraints are additional constraints applied to the entity.
	Constraints []Constraint
	// IsStrict indicates whether to use strict type checking (isa!).
	IsStrict bool
}

type FetchAttribute struct {
	// Key is the output key in the result JSON.
	Key string
	// Var is the variable whose attribute is being fetched.
	Var string
	// AttrName is the name of the attribute type to fetch.
	AttrName string
}

type FetchAttributeList struct {
	// Key is the output key in the result JSON.
	Key string
	// Var is the variable whose attributes are being fetched.
	Var string
	// AttrName is the name of the attribute type.
	AttrName string
}

type FetchClause struct {
	// Items are the items to fetch, which can be FetchItem nodes or raw strings.
	Items []any
}

type FetchFunction struct {
	// Key is the output key in the result JSON.
	Key string
	// FuncName is the name of the function (e.g., "iid").
	FuncName string
	// Var is the variable the function is applied to.
	Var string
}

type FetchItem interface {
	QueryNode

	// FetchKey returns the key under which the item will be returned in the result JSON.
	FetchKey() string
	// contains filtered or unexported methods
}

type FetchNestedWildcard struct {
	// Key is the output key in the result JSON.
	Key string
	// Var is the variable being fetched.
	Var string
}

type FetchVariable struct {
	// Key is the output key in the result JSON.
	Key string
	// Var is the variable being fetched.
	Var string
}

type FetchWildcard struct {
	// Key is the output key in the result JSON.
	Key string
	// Var is the variable whose attributes are all fetched.
	Var string
}

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

type FunctionCallValue struct {
	// Function is the name of the function to call.
	Function string
	// Args contains the arguments for the function, which can be Value nodes or variable strings.
	Args []any
}

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

type FunctionResultStage interface {
	Select(vars ...string) FunctionResultStage
	Sort(variable, direction string) FunctionResultStage
	Limit(count int) FunctionResultStage
	Offset(count int) FunctionResultStage
	Build() (string, error)
	Nodes() []QueryNode
	BuildNodes() []QueryNode
}

type FunctionStage interface {
	Select(vars ...string) FunctionResultStage
}

type HasConstraint struct {
	// AttrName is the name of the attribute type.
	AttrName string
	// Value is the value of the attribute (Value or variable string).
	Value any
}

type HasPattern struct {
	// ThingVar is the variable representing the thing (entity or relation).
	ThingVar string
	// AttrType is the type of the attribute.
	AttrType string
	// AttrVar is the variable representing the attribute instance.
	AttrVar string
}

type HasStatement struct {
	// SubjectVar is the variable representing the thing being assigned an attribute.
	SubjectVar string
	// AttrName is the name of the attribute type.
	AttrName string
	// Value is the value being assigned.
	Value Value
}

type IdentifierMatcher interface {
	IsIID(identifier string) bool
}

type IidConstraint struct {
	// IID is the unique instance identifier.
	IID string
}

type IidPattern struct {
	// Variable is the variable representing the thing.
	Variable string
	// IID is the instance ID string.
	IID string
}

type InsertClause struct {
	// Statements are the statements to insert.
	Statements []Statement
}

type IsaConstraint struct {
	// TypeName is the name of the type.
	TypeName string
	// Strict indicates whether to use strict type checking (isa!).
	Strict bool
}

type IsaStatement struct {
	// Variable is the variable name.
	Variable string
	// TypeName is the name of the type.
	TypeName string
}

type LetAssignment struct {
	// Variables are the variables being assigned values.
	Variables []string
	// Expression is the value or expression being assigned (Value or variable string).
	Expression any
	// IsStream indicates whether to use stream assignment ('in') or scalar assignment ('=').
	IsStream bool
}

type LimitClause struct {
	// Count is the maximum number of results to return.
	Count int
}

type LiteralValue struct {
	// Val is the actual value.
	Val any
	// ValueType specifies the TypeQL type of the value (e.g., "string", "long", "boolean").
	ValueType string
}

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

type MatchClause struct {
	// Patterns are the patterns to match.
	Patterns []Pattern
}

type MatchLetClause struct {
	// Patterns are optional match patterns evaluated before let assignments.
	Patterns []Pattern
	// Assignments are the let assignments in the clause.
	Assignments []LetAssignment
}

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

type MatchResultStage interface {
	Fetch(varName string, attrNames ...string) MatchResultStage
	Select(vars ...string) MatchResultStage
	Sort(variable, direction string) MatchResultStage
	Limit(count int) MatchResultStage
	Offset(count int) MatchResultStage
	Build() (string, error)
	Nodes() []QueryNode
	BuildNodes() []QueryNode
}

type MatchStage interface {
	Has(attrName string, value any) MatchStage
	Iid(iid string) MatchStage
	MatchByIdentifier(identifier, attrName string, matcher IdentifierMatcher) MatchStage
	Where(patterns ...Pattern) MatchStage
	Or(alternatives ...[]Pattern) MatchStage
	Let(assignments ...LetAssignment) MatchStage
	Set(attrName string, value any) MatchStage
	DeleteHas(attrVar, ownerVar string) MatchStage
	InsertHas(ownerVar, attrName string, value any) MatchStage
	DeleteThing() MatchStage
	Fetch(varName string, attrNames ...string) MatchResultStage
	Select(vars ...string) MatchResultStage
	Build() (string, error)
	Nodes() []QueryNode
	BuildNodes() []QueryNode
}

type NotPattern struct {
	// Patterns are the patterns to negate.
	Patterns []Pattern
}

type OffsetClause struct {
	// Count is the number of results to skip.
	Count int
}

type OrPattern struct {
	// Alternatives defines the multiple sets of patterns that satisfy the disjunction.
	Alternatives [][]Pattern
}

type PaginatedSearchOptions struct {
	VarName        string
	Limit          int
	Offset         int
	Sort           string // "name" for asc, "-name" for desc
	FetchIIDKey    string
	FetchEntityKey string
}

type Pattern interface {
	QueryNode
	// contains filtered or unexported methods
}

type PrefixIdentifierMatcher struct {
	Prefix string
}

type PutClause struct {
	// Statements are the statements defining what to put.
	Statements []Statement
}

type QueryNode interface {
	// contains filtered or unexported methods
}

type RawPattern struct {
	// Content is the raw TypeQL string.
	Content string
}

type RawStatement struct {
	// Content is the raw TypeQL string.
	Content string
}

type ReduceAssignment struct {
	// Variable is the variable receiving the aggregated value.
	Variable string
	// Expression is the aggregation expression (AggregateExpr or variable string).
	Expression any
}

type ReduceClause struct {
	// Assignments are the aggregate assignments.
	Assignments []ReduceAssignment
	// GroupBy is the optional variable to group the results by.
	GroupBy string
}

type RelationPattern struct {
	// Variable is the variable name for the matched relation.
	Variable string
	// TypeName is the name of the relation type.
	TypeName string
	// IsStrict indicates whether to use strict type checking (isa!).
	IsStrict bool
	// RolePlayers defines the participants in the relation.
	RolePlayers []RolePlayer
	// Constraints are additional constraints applied to the relation.
	Constraints []Constraint
}

type RelationStatement struct {
	// Variable is the optional variable name for the relation.
	Variable string
	// TypeName is the name of the relation type.
	TypeName string
	// RolePlayers defines the participants in the relation.
	RolePlayers []RolePlayer
	// IncludeVariable indicates whether to include the variable prefix in the compiled query.
	IncludeVariable bool
	// Attributes are inline attribute assignments for the relation.
	Attributes []HasStatement
}

type RolePlayer struct {
	// Role is the name of the role being played.
	Role string
	// PlayerVar is the variable name of the entity or relation playing the role (e.g., "$p").
	PlayerVar string
}

type SelectClause struct {
	// Variables are the variable names to project (e.g., ["$did", "$name"]).
	Variables []string
}

type SortClause struct {
	// Variable is the variable name to sort by (e.g., "$name").
	Variable string
	// Direction is "asc" or "desc".
	Direction string
}

type Statement interface {
	QueryNode
	// contains filtered or unexported methods
}

type SubTypePattern struct {
	// Variable is the variable representing the subtype.
	Variable string
	// ParentType is the name of the parent type.
	ParentType string
}

type UpdateClause struct {
	// Statements are the statements defining what to update.
	Statements []Statement
}

type Value interface {
	QueryNode
	// contains filtered or unexported methods
}

type ValueComparisonPattern struct {
	// Var is the variable being compared.
	Var string
	// Operator is the comparison operator (e.g., >, <, ==).
	Operator string
	// Value is the value to compare against (Value or variable string).
	Value any
}