cypher

type ArithmeticExpression struct {
	Left     Expression
	Partials []*PartialArithmeticExpression
}

type AssignmentOperator string

type Comparison struct {
	Left     Expression
	Partials []*PartialComparison
}

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

type CopyExtension[T any] func(value T) (T, bool)

type Create struct {
	Unique  bool
	Pattern []*PatternPart
	// contains filtered or unexported fields
}

type Delete struct {
	Detach      bool
	Expressions []Expression
}

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

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

type Expression SyntaxNode

type ExpressionList interface {
	Add(expression Expression)
	AddSlice(expressions []Expression)
	Get(index int) Expression
	GetAll() []Expression
	Len() int
	IndexOf(expression Expression) int
	Remove(expression Expression) bool
	Replace(index int, expression Expression)
}

type Fallible interface {
	AddError(err error)
	Errors() []error
}

type FilterExpression struct {
	Specifier *IDInCollection
	Where     *Where
}

type FunctionInvocation struct {
	Distinct  bool
	Namespace []string
	Name      string
	Arguments []Expression
	// contains filtered or unexported fields
}

type IDInCollection struct {
	Variable   *Variable
	Expression Expression
}

type KindMatcher struct {
	Reference Expression
	Kinds     graph.Kinds
	// IsExclusive changes the kind matching operator from overlap (PG &&) to a stricter "left contains right" (PG @>)
	IsExclusive bool
}

type Limit struct {
	Value Expression
}

type ListLiteral []Expression

type Literal struct {
	Value any
	Null  bool
}

type MapItem struct {
	Key   string
	Value Expression
}

type MapLiteral map[string]Expression

type Match struct {
	Optional bool
	Pattern  []*PatternPart
	Where    *Where
}

type Merge struct {
	PatternPart  *PatternPart
	MergeActions []*MergeAction
}

type MergeAction struct {
	OnCreate bool
	OnMatch  bool
	Set      *Set
}

type MultiPartQuery struct {
	Parts           []*MultiPartQueryPart
	SinglePartQuery *SinglePartQuery
}

type MultiPartQueryPart struct {
	ReadingClauses  []*ReadingClause
	UpdatingClauses []*UpdatingClause
	With            *With
}

type Negation struct {
	Expression Expression
}

type NodePattern struct {
	Variable   *Variable
	Kinds      graph.Kinds
	Properties Expression
}

type Operator string

type Order struct {
	Items []*SortItem
}

type Parameter struct {
	Symbol string
	Value  any
}

type Parenthetical struct {
	Expression Expression
}

type PartialArithmeticExpression struct {
	Operator Operator
	Right    Expression
}

type PartialComparison struct {
	Operator Operator
	Right    Expression
}

type PatternElement struct {
	Element Expression
}

type PatternPart struct {
	Variable                *Variable
	ShortestPathPattern     bool
	AllShortestPathsPattern bool
	PatternElements         []*PatternElement

	// PathDirectionReversed indicates the optimizer reversed this pattern's element order and
	// relationship directions so the traversal can be driven from the more selective terminal
	// endpoint. Downstream translation compensates for this when materializing a bound path so
	// that the path renders in its original left-to-right logical order.
	PathDirectionReversed bool
}

type PatternPredicate struct {
	PatternElements []*PatternElement
}

type PatternRange struct {
	StartIndex *int64
	EndIndex   *int64
}

type Projection struct {
	Distinct bool
	All      bool
	Order    *Order
	Skip     *Skip
	Limit    *Limit
	Items    []Expression
}

type ProjectionItem struct {
	Expression Expression
	Alias      *Variable
}

type Properties struct {
	Map       MapLiteral
	Parameter *Parameter
}

type PropertyLookup struct {
	Atom Expression

	// Symbol is the raw property key, not an already-rendered Cypher token.
	// Callers should not pre-wrap names in backticks; formatting handles that.
	Symbol string
}

type Quantifier struct {
	Type   QuantifierType
	Filter *FilterExpression
}

type QuantifierType string

type RangeQuantifier struct {
	Value string
}

type ReadingClause struct {
	Match  *Match
	Unwind *Unwind
}

type RegularQuery struct {
	SingleQuery *SingleQuery
}

type RelationshipPattern struct {
	Variable   *Variable
	Kinds      graph.Kinds
	Direction  graph.Direction
	Range      *PatternRange
	Properties Expression
}

type Remove struct {
	Items []*RemoveItem
}

type RemoveItem struct {
	KindMatcher *KindMatcher
	Property    Expression
}

type Return struct {
	Projection *Projection
}

type Set struct {
	Items []*SetItem
}

type SetItem struct {
	Left     Expression
	Operator AssignmentOperator
	Right    Expression
}

type SinglePartQuery struct {
	ReadingClauses  []*ReadingClause
	UpdatingClauses []Expression
	Return          *Return
	// contains filtered or unexported fields
}

type SingleQuery struct {
	SinglePartQuery *SinglePartQuery
	MultiPartQuery  *MultiPartQuery
}

type Skip struct {
	Value Expression
}

type SortItem struct {
	Ascending  bool
	Expression Expression
}

type SortOrder string

type SyntaxNode any

type UnaryAddOrSubtractExpression struct {
	Operator Operator
	Right    Expression
}

type Unwind struct {
	Expression Expression
	Variable   *Variable
}

type UpdatingClause struct {
	Clause Expression
	// contains filtered or unexported fields
}

type Variable struct {
	Symbol string
}

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

type With struct {
	Projection *Projection
	Where      *Where
}