nodes

type Assign struct {
	Target Expr
	Node   Node
	StmtCommon
}

type AssignBlock struct {
	Target Expr
	Body   []Node
	Filter *Filter
	StmtCommon
}

type BinExpr struct {
	Left  Expr
	Right Expr
	Op    string // same as lexer.TokenAdd etc. + "and", "or"
	ExprCommon
}

type Block struct {
	Name     string
	Body     []Node
	Scoped   bool
	Required bool
	StmtCommon
}

type Call struct {
	Node      Expr
	Args      []Expr
	Kwargs    []Keyword
	DynArgs   *Expr
	DynKwargs *Expr
	ExprCommon
}

type CallBlock struct {
	Call Call
	Body []Node
	MacroCall
	StmtCommon
}

type Compare struct {
	Expr Expr
	Ops  []Operand
	ExprCommon
}

type Concat struct {
	Nodes []Expr
	ExprCommon
}

type CondExpr struct {
	Test  Expr
	Expr1 Expr
	Expr2 *Expr
	ExprCommon
}

type Const struct {
	Value any
	LiteralCommon
}

type Dict struct {
	Items []Pair
	LiteralCommon
}

type EvalContextModifier struct {
	Options []Keyword
	StmtCommon
}

type Expr interface {
	CanAssign() bool
	Node
}

type ExprCommon NodeCommon

type ExprWithName interface {
	GetName() string
	Expr
}

type Extends struct {
	Template Expr
	StmtCommon
}

type Filter struct {
	FilterTestCommon
}

type FilterBlock struct {
	Body   []Node
	Filter *Filter
	StmtCommon
}

type FilterTestCommon struct {
	Node      *Expr
	Name      string
	Args      []Expr
	Kwargs    []Keyword // Jinja uses Pair but then other methods returns Keyword instead of Pair -_-
	DynArgs   *Expr
	DynKwargs *Expr
	ExprCommon
}

type For struct {
	Target    Node
	Iter      Node
	Body      []Node
	Else      []Node
	Test      *Node
	Recursive bool
	StmtCommon
}

type FromImport struct {
	Template    Expr
	WithContext bool
	Names       [][]string // name or name with alias
	StmtCommon
}

type Getattr struct {
	Node Expr
	Attr string
	Ctx  string
	ExprCommon
}

type Getitem struct {
	Node Expr
	Arg  Expr
	Ctx  string
	ExprCommon
}

type Helper Node

type HelperCommon NodeCommon

type If struct {
	Test Node
	Body []Node
	Elif []If
	Else []Node
	StmtCommon
}

type Import struct {
	Template    Expr
	WithContext bool
	Target      string
	StmtCommon
}

type Include struct {
	Template      Expr
	WithContext   bool
	IgnoreMissing bool
	StmtCommon
}

type Keyword struct {
	Key   string
	Value Expr
	HelperCommon
}

type List struct {
	Items []Expr
	LiteralCommon
}

type Literal Expr

type LiteralCommon ExprCommon

type Macro struct {
	Name string
	Body []Node
	MacroCall
	StmtCommon
}

type MacroCall struct {
	Args     []Name
	Defaults []Expr
}

type NSRef struct {
	Name string
	Attr string
	ExprCommon
}

type Name struct {
	Name string
	Ctx  string
	ExprCommon
}

type Node interface {
	GetLineno() int
	SetCtx(ctx string)
}

type NodeCommon struct {
	Lineno int
}

type Operand struct {
	Op   string
	Expr Node
	HelperCommon
}

type Output struct {
	Nodes []Expr
	StmtCommon
}

type Pair struct {
	Key   Expr
	Value Expr
	HelperCommon
}

type Scope struct {
	Body []Node
	StmtCommon
}

type ScopedEvalContextModifier struct {
	Body []Node
	EvalContextModifier
}

type SetWithContexter interface {
	SetWithContext(bool)
	Stmt
}

type Slice struct {
	Start *Expr
	Stop  *Expr
	Step  *Expr
	ExprCommon
}

type Stmt interface {
	Node
}

type StmtCommon NodeCommon

type StmtWithNodes interface {
	GetNodes() []Expr
	Stmt
}

type Template struct {
	Body []Node
	NodeCommon
}

type TemplateData struct {
	Data string
	LiteralCommon
}

type Test struct {
	FilterTestCommon
}

type Tuple struct {
	Items []Expr
	Ctx   string
	LiteralCommon
}

type UnaryExpr struct {
	Node Expr
	Op   string // same as lexer.TokenAdd etc. + "not"
	ExprCommon
}

type With struct {
	Targets []Expr
	Values  []Expr
	Body    []Node
	StmtCommon
}