htmlbind

type ActionRef struct {
	// Component is the declaration the reference appears in.
	Component string
	// Handler is the Go function name the attribute named.
	Handler string
	// Element is the element carrying the attribute, such as form or button.
	Element string
	// Pos is the attribute position, for a diagnostic that can quote the source.
	Pos Position
}

type Annotation = syntax.Annotation

type Asset struct {
	Kind AssetKind
	// Base is the file name without its extension.
	Base string
	// Extension is css for a stylesheet and js for a script, without a dot.
	Extension string
	Content   []byte
	// URL is the reference written into the emitted link or script tag.
	URL string
}

type AssetKind string

type Attribute struct {
	Kind    string          `json:"kind"`
	Pos     Position        `json:"pos"`
	Name    string          `json:"name"`
	Boolean bool            `json:"boolean,omitempty"`
	Value   []AttributePart `json:"value,omitempty"`
}

type AttributePart struct {
	Kind       string   `json:"kind"`
	Pos        Position `json:"pos"`
	Context    string   `json:"context,omitempty"`
	Text       string   `json:"text,omitempty"`
	Expression Expr     `json:"expression,omitempty"`
}

type AwaitBinding = syntax.AwaitBinding

type AwaitNode = syntax.AwaitNode

type BinaryExpr = syntax.BinaryExpr

type Body = []Node

type CallExpr = syntax.CallExpr

type CommentNode struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Text string   `json:"text"`
}

type CompileError struct {
	Filename string
	Pos      Position
	Message  string
}

type ComponentNode struct {
	Kind        string      `json:"kind"`
	Pos         Position    `json:"pos"`
	Name        string      `json:"name"`
	Arguments   []Attribute `json:"arguments,omitempty"`
	Children    []Node      `json:"children,omitempty"`
	SelfClosing bool        `json:"selfClosing,omitempty"`
}

type ConditionalExpr = syntax.ConditionalExpr

type Declaration = syntax.Declaration

type DoctypeNode struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Text string   `json:"text"`
}

type ElementNode struct {
	Kind        string      `json:"kind"`
	Pos         Position    `json:"pos"`
	Name        string      `json:"name"`
	Attributes  []Attribute `json:"attributes,omitempty"`
	Children    []Node      `json:"children,omitempty"`
	SelfClosing bool        `json:"selfClosing,omitempty"`
}

type EnumDecl = syntax.EnumDecl

type EnumMember = syntax.EnumMember

type Expr = syntax.Expr

type ExpressionNode = syntax.ExpressionNode

type ExternalDecl = syntax.ExternalDecl

type Field = syntax.Field

type ForNode = syntax.ForNode

type GenerateOptions struct {
	// Package overrides the template package/module declaration.
	Package string
	// Unit names the generation unit whose assets are extracted. Empty derives
	// it from the template file name.
	Unit string
	// PublicURLBase prefixes generated asset file names in head references.
	// Empty uses DefaultPublicURLBase. The value is used verbatim, so an
	// absolute URL path and a full CDN URL behave the same.
	PublicURLBase string
	// ContextExternals names the external functions whose Go implementation
	// takes a leading context.Context. Those calls receive the boundary's
	// context; every other external is called as an ordinary function.
	//
	// The caller discovers this by reading the package's Go sources, so the
	// template declaration stays the same either way and the choice belongs to
	// whoever writes the implementation.
	ContextExternals map[string]bool
	// PreserveWhitespace turns off requirement:static-whitespace-normalization,
	// so static output keeps the authoring indentation and newlines byte for
	// byte. It exists for a project comparing generated markup against
	// pre-existing golden files.
	PreserveWhitespace bool
	// ServerActions maps each handler name a template reaches through
	// ServerActionAttr to the endpoint URL the lowering writes. The caller
	// resolves it, because the URL depends on the route the template serves and
	// the compiler cannot see that; [ActionRefs] reports what needs resolving.
	//
	// A reference with no entry here is a compile error, so a template naming a
	// handler nobody resolved never silently emits a dead element.
	ServerActions map[string]string
	// ServerActionResolver answers a name ServerActions does not hold. It is what
	// lets a framework address a handler from its own route table, for a template
	// that sits outside the tree route discovery walks.
	//
	// The map wins, so configuring a resolver cannot retarget an action a
	// discovered package already declares.
	ServerActionResolver func(name string) (url string, ok bool)
	// ServerActionAttr is the attribute the lowering writes. Empty uses
	// [DefaultActionAttr]. A framework driving an existing client library points
	// it at that library's vocabulary, such as hx-post.
	ServerActionAttr string
}

type HeadNode struct {
	Kind     string   `json:"kind"`
	Pos      Position `json:"pos"`
	Children []Node   `json:"children,omitempty"`
}

type IdentifierExpr = syntax.IdentifierExpr

type IfNode = syntax.IfNode

type ImportDecl = syntax.ImportDecl

type IndexExpr = syntax.IndexExpr

type LiteralExpr = syntax.LiteralExpr

type MemberExpr = syntax.MemberExpr

type Module = syntax.Module

type Node = syntax.Node

type PackageDecl = syntax.PackageDecl

type Parameter = syntax.Parameter

type ParseError = syntax.ParseError

type Position = syntax.Position

type Result struct {
	GoSource []byte
	Assets   []Asset
}

type Signature struct {
	// Name is the declaration name as written in the template.
	Name string
	// Exported reports the export modifier.
	Exported bool
	// Parameters are in declaration order.
	Parameters []SignatureParam
}

type SignatureParam struct {
	// Name is the parameter name as written in the template.
	Name string
	// GoType is the Go type of the generated parameter struct field. An async
	// parameter is already wrapped, so it reads htmlbind.Pending[T].
	GoType string
	// TemplateType is the type as written in the template, kept for diagnostics
	// that should quote the source rather than its lowering.
	TemplateType string
	// Async marks a parameter the caller settles through htmlbind.Pending.
	Async bool
	// Slot marks an html parameter, which a wrapper fills rather than a caller
	// passing data.
	Slot bool
}

type SlotNode struct {
	Kind     string   `json:"kind"`
	Pos      Position `json:"pos"`
	Name     string   `json:"name,omitempty"`
	Required bool     `json:"required,omitempty"`
	Default  []Node   `json:"default,omitempty"`
}

type TemplateDecl = syntax.TemplateDecl

type TextNode struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Text string   `json:"text"`
}

type TypeDecl = syntax.TypeDecl

type TypeRef = syntax.TypeRef

type UnaryExpr = syntax.UnaryExpr