ast

type BinaryExpr struct {
	Left     Expr
	Operator string
	Right    Expr
	Start    Pos
	EndPos   Pos
}

type BoolLit struct {
	Value  bool
	Start  Pos
	EndPos Pos
}

type CaseExpr struct {
	Operand Expr
	Whens   []*WhenClause
	Else    Expr
	Start   Pos
	EndPos  Pos
}

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

type CreateClause struct {
	Pattern *PatternExpr
	Start   Pos
	EndPos  Pos
}

type CreateStmt struct {
	Pattern *PatternExpr
	Clauses []Clause
	Start   Pos
	EndPos  Pos
}

type DeleteClause struct {
	Detach bool
	Items  []Expr
	Start  Pos
	EndPos Pos
}

type DeleteStmt struct {
	Detach bool
	Items  []Expr
	Start  Pos
	EndPos Pos
}

type Direction int

type ExistsExpr struct {
	Pattern *PatternExpr
	Expr    Expr
	Start   Pos
	EndPos  Pos
}

type Expr interface {
	Node
	// contains filtered or unexported methods
}

type FloatLit struct {
	Value  float64
	Start  Pos
	EndPos Pos
}

type FuncCall struct {
	Name     string
	Args     []Expr
	Distinct bool
	Start    Pos
	EndPos   Pos
}

type Ident struct {
	Name   string
	Start  Pos
	EndPos Pos
}

type InExpr struct {
	Left   Expr
	Right  Expr
	Start  Pos
	EndPos Pos
}

type IntegerLit struct {
	Value  int64
	Start  Pos
	EndPos Pos
}

type IsNullExpr struct {
	Expr   Expr
	IsNot  bool
	Negate bool
	Start  Pos
	EndPos Pos
}

type ListComprehension struct {
	Var        string
	Variable   string
	InExpr     Expr
	List       Expr
	Where      Expr
	Filter     Expr
	Expr       Expr
	Projection Expr
	Start      Pos
	EndPos     Pos
}

type ListExpr struct {
	Elements []Expr
	Start    Pos
	EndPos   Pos
}

type ListIndexExpr struct {
	List   Expr
	Index  Expr
	Start  Pos
	EndPos Pos
}

type ListLit struct {
	Elements []Expr
	Start    Pos
	EndPos   Pos
}

type ListSliceExpr struct {
	List   Expr
	From   Expr
	To     Expr
	Start  Pos
	EndPos Pos
}

type MapExpr struct {
	Pairs  []*MapPair
	Start  Pos
	EndPos Pos
}

type MapLit struct {
	Properties map[string]Expr
	Start      Pos
	EndPos     Pos
}

type MapPair struct {
	Key    string
	Value  Expr
	Start  Pos
	EndPos Pos
}

type MatchClause struct {
	Optional bool
	Pattern  *PatternExpr
	Where    *WhereExpr
	Return   *ReturnExpr
	Delete   *DeleteClause
	Start    Pos
	EndPos   Pos
}

type MatchStmt struct {
	Optional bool
	Clauses  []Clause
	Start    Pos
	EndPos   Pos
}

type MergeClause struct {
	Pattern  *PatternExpr
	OnCreate []*SetItem
	OnMatch  []*SetItem
	Start    Pos
	EndPos   Pos
}

type MergeStmt struct {
	Pattern  *PatternExpr
	Clause   *MergeClause
	OnCreate []*SetItem
	OnMatch  []*SetItem
	Start    Pos
	EndPos   Pos
}

type Node interface {
	Position() Pos
	End() Pos
	String() string
}

type NodePattern struct {
	Variable     string
	Labels       []string
	Properties   map[string]Expr
	PropertyExpr Expr
	Start        Pos
	EndPos       Pos
}

type NullLit struct {
	Start  Pos
	EndPos Pos
}

type OrderByExpr struct {
	Items  []*OrderByItem
	Start  Pos
	EndPos Pos
}

type OrderByItem struct {
	Expr       Expr
	Descending bool
	Ascending  bool
	Start      Pos
	EndPos     Pos
}

type Param struct {
	Name   string
	Start  Pos
	EndPos Pos
}

type ParamExpr struct {
	Name   string
	Start  Pos
	EndPos Pos
}

type PathExpr struct {
	Nodes         []*NodePattern
	Relationships []*RelationPattern
	Start         Pos
	EndPos        Pos
}

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

type PatternComprehension struct {
	Pattern *PatternExpr
	Where   Expr
	Expr    Expr
	Start   Pos
	EndPos  Pos
}

type PatternExpr struct {
	Parts  []*PatternPart
	Paths  []*PathExpr
	Start  Pos
	EndPos Pos
}

type PatternExprItem struct {
	Variable string
	Path     *PathExpr
	Start    Pos
	EndPos   Pos
}

type PatternPart struct {
	Variable string
	Path     *PathExpr
	Start    Pos
	EndPos   Pos
}

type Pos struct {
	Line   int
	Column int
	Offset int
}

type PropertyAccessExpr struct {
	Target   Expr
	Property string
	Start    Pos
	EndPos   Pos
}

type Query struct {
	Statements []Stmt
	Start      Pos
	EndPos     Pos
}

type RelationPattern struct {
	Variable       string
	Types          []string
	Direction      Direction
	Properties     map[string]Expr
	MinHops        *int
	MaxHops        *int
	VariableLength bool
	RightArrow     bool
	LeftArrow      bool
	Start          Pos
	EndPos         Pos
}

type RemoveClause struct {
	Items  []*RemoveItemExpr
	Start  Pos
	EndPos Pos
}

type RemoveItemExpr struct {
	Target  Expr
	IsLabel bool
	Label   string
	Start   Pos
	EndPos  Pos
}

type RemoveStmt struct {
	Items  []*RemoveItemExpr
	Start  Pos
	EndPos Pos
}

type ReturnClause struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Start    Pos
	EndPos   Pos
}

type ReturnExpr struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Start    Pos
	EndPos   Pos
}

type ReturnItemExpr struct {
	Expr   Expr
	Alias  string
	Start  Pos
	EndPos Pos
}

type ReturnStmt struct {
	Distinct bool
	Items    []*ReturnItemExpr
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Return   *ReturnExpr
	Start    Pos
	EndPos   Pos
}

type SetClause struct {
	Items  []*SetItem
	Start  Pos
	EndPos Pos
}

type SetItem struct {
	Target   Expr
	Value    Expr
	Operator string
	IsLabel  bool
	Start    Pos
	EndPos   Pos
}

type SetStmt struct {
	Items  []*SetItem
	Start  Pos
	EndPos Pos
}

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

type StringLit struct {
	Value  string
	Start  Pos
	EndPos Pos
}

type UnaryExpr struct {
	Operator string
	Operand  Expr
	Start    Pos
	EndPos   Pos
}

type UnionClause struct {
	All    bool
	Start  Pos
	EndPos Pos
}

type UnwindClause struct {
	Expr   Expr
	Var    string
	Start  Pos
	EndPos Pos
}

type UnwindStmt struct {
	List     Expr
	Variable string
	Return   *ReturnExpr
	Start    Pos
	EndPos   Pos
}

type Visitor interface {
	Visit(node Node) (w Visitor, err error)
}

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

type WhenClause struct {
	Condition Expr
	Result    Expr
	Start     Pos
	EndPos    Pos
}

type WhereClause struct {
	Expr   Expr
	Start  Pos
	EndPos Pos
}

type WhereExpr struct {
	Expr   Expr
	Start  Pos
	EndPos Pos
}

type WithClause struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Where    Expr
	Start    Pos
	EndPos   Pos
}

type WithStmt struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Where    Expr
	Start    Pos
	EndPos   Pos
}