syntax

type Annotation struct {
	Pos  Position        `json:"pos"`
	Name string          `json:"name"`
	Args []AnnotationArg `json:"args,omitempty"`
}

type AnnotationArg struct {
	Pos   Position `json:"pos"`
	Name  string   `json:"name"`
	Value string   `json:"value"`
}

type AwaitBinding struct {
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
	Call Expr     `json:"call"`
}

type AwaitNode struct {
	Kind     string         `json:"kind"`
	Pos      Position       `json:"pos"`
	Context  string         `json:"context"`
	Bindings []AwaitBinding `json:"bindings"`
	Primary  []Node         `json:"primary"`
	Fallback []Node         `json:"fallback"`
	// HasRecover distinguishes a declared but empty recover subtree from an
	// omitted one, which keeps the committed fallback instead.
	HasRecover bool     `json:"hasRecover,omitempty"`
	Recover    []Node   `json:"recover,omitempty"`
	ErrorName  string   `json:"errorName,omitempty"`
	ErrorPos   Position `json:"errorPos,omitempty"`
}

type BinaryExpr struct {
	Kind     string   `json:"kind"`
	Pos      Position `json:"pos"`
	Operator string   `json:"operator"`
	Left     Expr     `json:"left"`
	Right    Expr     `json:"right"`
}

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

type BodyPrinter interface {
	PrintBody(p *Printer, decl *TemplateDecl) error
}

type CallExpr struct {
	Kind      string   `json:"kind"`
	Pos       Position `json:"pos"`
	Callee    Expr     `json:"callee"`
	Arguments []Expr   `json:"arguments,omitempty"`
}

type Comment struct {
	Pos Position `json:"pos"`
	// Text is the comment including its own delimiters, so a printer never has
	// to reconstruct whether it was a line or a block comment.
	Text string `json:"text"`
	// Block reports a /* */ comment.
	Block bool `json:"block,omitempty"`
	// Trailing reports a comment that began on a line which already had code on
	// it, which is what decides whether a printer keeps it on that line.
	Trailing bool `json:"trailing,omitempty"`
	// BlankBefore reports a blank line between the previous content and this
	// comment, so a deliberately detached comment stays detached.
	BlankBefore bool `json:"blankBefore,omitempty"`
	// contains filtered or unexported fields
}

type ConditionalExpr struct {
	Kind      string   `json:"kind"`
	Pos       Position `json:"pos"`
	Condition Expr     `json:"condition"`
	Then      Expr     `json:"then"`
	Else      Expr     `json:"else"`
}

type DeclComment struct {
	Line        int
	Text        string
	Trailing    bool
	BlankBefore bool
	// contains filtered or unexported fields
}

type DeclFormatter struct {
	P *Printer
	// contains filtered or unexported fields
}

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

type Embedded struct {
	Text          string
	StartOffset   int
	ContentOffset int
}

type EnumDecl struct {
	Kind    string       `json:"kind"`
	Pos     Position     `json:"pos"`
	Name    string       `json:"name"`
	Members []EnumMember `json:"members"`
}

type EnumMember struct {
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
}

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

type ExpressionNode struct {
	Kind       string   `json:"kind"`
	Pos        Position `json:"pos"`
	Context    string   `json:"context"`
	Expression Expr     `json:"expression"`
}

type ExternalDecl struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
	// Async marks a function that runs concurrently and may fail. It is a
	// keyword rather than an annotation because it changes the Go signature the
	// package must provide.
	Async bool `json:"async,omitempty"`
	// Live marks a function that yields many values over time rather than
	// settling once. It is a keyword for the same reason Async is: the Go
	// signature becomes an iter.Seq2 over the result type, with a leading
	// context that is mandatory rather than optional, because an endless source
	// has to be stoppable.
	Live       bool        `json:"live,omitempty"`
	Parameters []Parameter `json:"parameters,omitempty"`
	Result     TypeRef     `json:"result"`
}

type Field struct {
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
	Type TypeRef  `json:"type"`
}

type ForNode struct {
	Kind     string   `json:"kind"`
	Pos      Position `json:"pos"`
	Context  string   `json:"context"`
	Variable string   `json:"variable"`
	Index    string   `json:"index,omitempty"`
	Iterable Expr     `json:"iterable"`
	Body     []Node   `json:"body"`
}

type FormatParser interface {
	ParseBody(*BodyContext, string) ([]Node, *Terminator, error)
}

type IdentifierExpr struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
}

type IfNode struct {
	Kind      string   `json:"kind"`
	Pos       Position `json:"pos"`
	Context   string   `json:"context"`
	Condition Expr     `json:"condition"`
	Then      []Node   `json:"then"`
	Else      []Node   `json:"else,omitempty"`
}

type ImportDecl struct {
	Pos   Position `json:"pos"`
	Path  string   `json:"path"`
	Alias string   `json:"alias,omitempty"`
}

type IndexExpr struct {
	Kind   string   `json:"kind"`
	Pos    Position `json:"pos"`
	Object Expr     `json:"object"`
	Index  Expr     `json:"index"`
}

type LiteralExpr struct {
	Kind      string   `json:"kind"`
	Pos       Position `json:"pos"`
	ValueKind string   `json:"valueKind"`
	Value     any      `json:"value"`
}

type MemberExpr struct {
	Kind   string   `json:"kind"`
	Pos    Position `json:"pos"`
	Object Expr     `json:"object"`
	Member string   `json:"member"`
}

type Module struct {
	Pos          Position      `json:"pos"`
	Package      *PackageDecl  `json:"package,omitempty"`
	Imports      []ImportDecl  `json:"imports,omitempty"`
	Declarations []Declaration `json:"declarations"`
	// Comments holds every comment in the declaration part of the file, in
	// source order. They are attached by position rather than to nodes, because
	// a printer walks declarations in order anyway and node-by-node plumbing
	// would touch every declaration type for no extra information.
	Comments []Comment `json:"comments,omitempty"`
}

type NameRule struct {
	// PascalCase requires an uppercase initial, exported or not. HTML sets it
	// because in markup an element whose tag name starts uppercase is the
	// component-call syntax: a lowercase component could never be called, and
	// would collide with a standard element.
	PascalCase bool
	// ExportedNameIsGo says the public generated identifier is the declaration
	// name itself, so an exported declaration needs an exported name. A format
	// that composes its public name instead leaves this off.
	ExportedNameIsGo bool
	// PrivateNameIsGo says the private generated identifier is also the name
	// itself, so an unexported declaration needs an unexported name. A format
	// that prefixes its private name leaves this off, and may then keep an
	// uppercase name on a private declaration.
	PrivateNameIsGo bool
}

type Node interface {
	NodeType() string
}

type PackageDecl struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
}

type Parameter struct {
	Pos  Position `json:"pos"`
	Name string   `json:"name"`
	Type TypeRef  `json:"type"`
}

type ParseError struct {
	Filename string
	Offset   int
	Line     int
	Column   int
	Message  string
}

type Position struct {
	Line int `json:"line"`
	Col  int `json:"col"`
}

type PrintOptions struct {
	// Width is the soft line width; zero uses DefaultWidth.
	Width int
	// Indent is one indentation level; empty uses DefaultIndent.
	Indent string
	// PreserveWhitespace mirrors the generator option of the same name. With it
	// set, static whitespace is no longer collapsed at generation time, so an
	// HTML layout pass may only touch positions the HTML parser discards.
	PreserveWhitespace bool
}

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

type RootDeclaration struct {
	Keyword      string
	NodeType     string
	OutputPrefix string
	Context      string
	Parser       FormatParser
	// Names states what this format needs from a declaration name. The zero
	// value asks for nothing, which is what a format wants when every generated
	// identifier is composed rather than copied.
	Names NameRule
}

type RootPrinter struct {
	// Kind is the TemplateDecl.Kind the format parser assigned.
	Kind string
	// Keyword is the root declaration keyword to print.
	Keyword string
	Printer BodyPrinter
}

type TemplateDecl struct {
	Kind        string       `json:"kind"`
	Pos         Position     `json:"pos"`
	Exported    bool         `json:"exported"`
	Annotations []Annotation `json:"annotations,omitempty"`
	Name        string       `json:"name"`
	Parameters  []Parameter  `json:"parameters,omitempty"`
	Output      TypeRef      `json:"output"`
	Body        any          `json:"body"`
}

type Terminator struct {
	Kind          TerminatorKind
	Pos           Position
	Header        string
	HeaderOffset  int
	ContentOffset int
}

type TerminatorKind string

type TypeDecl struct {
	Kind   string   `json:"kind"`
	Pos    Position `json:"pos"`
	Name   string   `json:"name"`
	Fields []Field  `json:"fields"`
}

type TypeRef struct {
	Pos       Position  `json:"pos"`
	Name      string    `json:"name"`
	Arguments []TypeRef `json:"arguments,omitempty"`
	Array     bool      `json:"array,omitempty"`
	Optional  bool      `json:"optional,omitempty"`
	// Async marks a value the caller starts and the template waits for in an
	// await clause. It modifies the whole type expression, so `async Order[]`
	// is one pending array rather than an array of pending values.
	Async bool `json:"async,omitempty"`
}

type UnaryExpr struct {
	Kind     string   `json:"kind"`
	Pos      Position `json:"pos"`
	Operator string   `json:"operator"`
	Operand  Expr     `json:"operand"`
}