stencil

type Alignment = xml.Alignment

type BinaryOpNode struct {
	Left     ExpressionNode
	Operator string
	Right    ExpressionNode
}

type Body = xml.Body

type BodyElement = xml.BodyElement

type BorderProperties = xml.BorderProperties

type Break = xml.Break

type CacheConfig struct {
	// MaxSize is the maximum number of templates to cache. 0 disables caching.
	MaxSize int
	// TTL is the time-to-live for cached templates. 0 means no expiration.
	TTL time.Duration
}

type CellMargin = xml.CellMargin

type Color = xml.Color

type Config struct {
	// CacheMaxSize is the maximum number of templates to cache. 0 disables caching.
	CacheMaxSize int
	// CacheTTL is the time-to-live for cached templates. 0 means no expiration.
	CacheTTL time.Duration
	// LogLevel controls the verbosity of logging (debug, info, warn, error)
	LogLevel string
	// MaxRenderDepth controls the maximum depth of nested template includes/fragments
	MaxRenderDepth int
	// StrictMode enables strict template validation and error handling
	StrictMode bool
}

type ContentTypeDefault struct {
	Extension   string `xml:"Extension,attr"`
	ContentType string `xml:"ContentType,attr"`
}

type ContentTypeOverride struct {
	PartName    string `xml:"PartName,attr"`
	ContentType string `xml:"ContentType,attr"`
}

type ContentTypes struct {
	XMLName   xml.Name              `xml:"Types"`
	Namespace string                `xml:"xmlns,attr"`
	Defaults  []ContentTypeDefault  `xml:"Default"`
	Overrides []ContentTypeOverride `xml:"Override"`
}

type ContextError struct {
	Operation string
	Context   map[string]interface{}
	Cause     error
}

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

type ControlStructure interface {
	Render(data TemplateData) (string, error)
	RenderWithContext(data TemplateData, ctx *renderContext) (string, error)
	String() string
}

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

type Document = xml.Document

type DocumentError struct {
	Operation string
	Path      string
	Cause     error
}

type DocumentPart struct {
	Name    string
	Content []byte
}

type DocumentStyle struct {
	XMLName xml.Name `xml:"style"`
	Type    string   `xml:"type,attr"`
	StyleID string   `xml:"styleId,attr"`
	RawXML  []byte   `xml:",innerxml"` // Store the entire style definition as raw XML
}

type DocxReader struct {
	Parts map[string]*zip.File
	// contains filtered or unexported fields
}

type ElementWithPath struct {
	Type    string   // "text" or "break"
	Content string   // text content (for text elements)
	Path    []string // formatting path
}

type ElsIfNode struct {
	Condition ExpressionNode
	Body      []ControlStructure
}

type Empty = xml.Empty

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

type EvaluationError struct {
	Expression string
	Cause      error
}

type ExpressionContentNode struct {
	Expression ExpressionNode
}

type ExpressionNode interface {
	String() string
	Evaluate(data TemplateData) (interface{}, error)
}

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

type ExpressionToken struct {
	Type  ExpressionTokenType
	Value string
	Pos   int
}

type ExpressionTokenType int

type ExtractReferencesInput struct {
	DocxBytes          []byte `json:"-"`
	TemplateRevisionID string `json:"templateRevisionId,omitempty"`
}

type ExtractReferencesResult struct {
	References []TemplateTokenRef `json:"references"`
	Metadata   StencilMetadata    `json:"metadata"`
}

type FieldAccessNode struct {
	Object ExpressionNode
	Field  string
}

type FieldDefinition struct {
	Path       string `json:"path"`
	Type       string `json:"type"`
	Nullable   bool   `json:"nullable,omitempty"`
	Collection bool   `json:"collection,omitempty"`
}

type Fields map[string]interface{}

type Font = xml.Font

type ForNode struct {
	Variable   string
	IndexVar   string // Optional index variable for indexed loops
	Collection ExpressionNode
	Body       []ControlStructure
}

type Function interface {
	// Call executes the function with the given arguments
	Call(args ...interface{}) (interface{}, error)

	// Name returns the function name
	Name() string

	// MinArgs returns the minimum number of arguments required
	MinArgs() int

	// MaxArgs returns the maximum number of arguments allowed (-1 for unlimited)
	MaxArgs() int
}

type FunctionCallNode struct {
	Name string
	Args []ExpressionNode
}

type FunctionDefinition struct {
	Name       string     `json:"name"`
	MinArgs    int        `json:"minArgs,omitempty"`
	MaxArgs    int        `json:"maxArgs,omitempty"`
	ArgKinds   [][]string `json:"argKinds,omitempty"`
	ReturnKind string     `json:"returnKind,omitempty"`
}

type FunctionError struct {
	Function string
	Args     []interface{}
	Message  string
}

type FunctionProvider interface {
	// ProvideFunctions returns a map of function name to Function implementation
	ProvideFunctions() map[string]Function
}

type FunctionRegistry interface {
	// RegisterFunction adds a function to the registry
	RegisterFunction(fn Function) error

	// GetFunction retrieves a function by name
	GetFunction(name string) (Function, bool)

	// ListFunctions returns all registered function names
	ListFunctions() []string
}

type GridColumn = xml.GridColumn

type GridSpan = xml.GridSpan

type HTMLNode struct {
	Type     string
	Content  string
	Children []*HTMLNode
	Attrs    map[string]string
}

type HTMLRun struct {
	Properties *RunProperties
	Content    []HTMLRunElement
}

type HTMLRunElement struct {
	Type string // "text" or "break"
	Text string // for text elements
}

type HTMLRuns struct {
	Runs []HTMLRun
}

type Height = xml.Height

type Hyperlink = xml.Hyperlink

type IfNode struct {
	Condition ExpressionNode
	ThenBody  []ControlStructure
	ElseBody  []ControlStructure
	ElsIfs    []*ElsIfNode
}

type IncludeNode struct {
	FragmentName ExpressionNode
}

type Indentation = xml.Indentation

type IndexAccessNode struct {
	Object ExpressionNode
	Index  ExpressionNode
}

type IssueSeverity string

type Kern = xml.Kern

type Lang = xml.Lang

type LinkReplacementMarker struct {
	URL string
}

type LiteralNode struct {
	Value interface{}
}

type LogLevel int

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

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

type OOXMLFragment struct {
	Content interface{} // The OOXML content (e.g., Break, etc.)
}

type Option func(*Engine)

type Paragraph = xml.Paragraph

type ParagraphContent = xml.ParagraphContent

type ParagraphProperties = xml.ParagraphProperties

type ParseError struct {
	Message  string
	Token    string
	Position int
}

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

type ProofErr = xml.ProofErr

type RawXMLElement = xml.RawXMLElement

type Relationship struct {
	ID         string `xml:"Id,attr"`
	Type       string `xml:"Type,attr"`
	Target     string `xml:"Target,attr"`
	TargetMode string `xml:"TargetMode,attr,omitempty"`
}

type Relationships struct {
	XMLName      xml.Name       `xml:"Relationships"`
	Namespace    string         `xml:"xmlns,attr"`
	Relationship []Relationship `xml:"Relationship"`
}

type Run = xml.Run

type RunProperties = xml.RunProperties

type RunStyle = xml.RunStyle

type Shading = xml.Shading

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

type Size = xml.Size

type Spacing = xml.Spacing

type StencilIssueCode string

type StencilMetadata struct {
	DocumentHash       string `json:"documentHash"`
	TemplateRevisionID string `json:"templateRevisionId,omitempty"`
	ParserVersion      string `json:"parserVersion"`
}

type StencilValidationIssue struct {
	ID          string           `json:"id"`
	Severity    IssueSeverity    `json:"severity"`
	Code        StencilIssueCode `json:"code"`
	Message     string           `json:"message"`
	Token       TemplateTokenRef `json:"token"`
	Location    TemplateLocation `json:"location"`
	Suggestions []string         `json:"suggestions,omitempty"`
}

type StencilValidationSummary struct {
	CheckedTokens      int `json:"checkedTokens"`
	ErrorCount         int `json:"errorCount"`
	WarningCount       int `json:"warningCount"`
	ReturnedIssueCount int `json:"returnedIssueCount"`
}

type Style = xml.Style

type Styles struct {
	XMLName   xml.Name        `xml:"styles"`
	Namespace string          `xml:"xmlns:w,attr"`
	Styles    []DocumentStyle `xml:"style"`
	RawXML    []byte          `xml:",innerxml"` // Store the raw XML
}

type Tab = xml.Tab

type Table = xml.Table

type TableBorders = xml.TableBorders

type TableCell = xml.TableCell

type TableCellBorders = xml.TableCellBorders

type TableCellMargins = xml.TableCellMargins

type TableCellProperties = xml.TableCellProperties

type TableColumnMarker struct {
	Action         string // "hide"
	ColumnIndex    int
	ResizeStrategy string // "redistribute", "proportional", "fixed", or empty for default
}

type TableContext struct {
	TableIndex int    // Index of the table in the document
	Table      *Table // Pointer to the table
	RowIndex   int    // Current row being processed
	CellIndex  int    // Current cell being processed
	ColumnSpan int    // Column span of current cell
}

type TableGrid = xml.TableGrid

type TableIndentation = xml.TableIndentation

type TableInfo struct {
	Index       int   // Index of the table in the document
	RowCount    int   // Number of rows
	ColumnCount int   // Number of columns (maximum across all rows)
	HasGrid     bool  // Whether the table has explicit column definitions
	GridWidths  []int // Column widths from table grid
}

type TableLayout = xml.TableLayout

type TableLook = xml.TableLook

type TableProperties = xml.TableProperties

type TableRow = xml.TableRow

type TableRowMarker struct {
	Action string // "hide" for hideRow()
}

type TableRowProperties = xml.TableRowProperties

type Tabs = xml.Tabs

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

type TemplateData map[string]interface{}

type TemplateError struct {
	Message string
	Line    int
	Column  int
}

type TemplateLocation struct {
	Part           string `json:"part"`
	ParagraphIndex int    `json:"paragraphIndex"`
	RunIndex       int    `json:"runIndex"`
	CharStartUTF16 int    `json:"charStartUtf16"`
	CharEndUTF16   int    `json:"charEndUtf16"`
	TokenOrdinal   int    `json:"tokenOrdinal"`
	AnchorID       string `json:"anchorId,omitempty"`
}

type TemplateTokenRef struct {
	Raw        string           `json:"raw"`
	Kind       TokenKind        `json:"kind"`
	Expression string           `json:"expression,omitempty"`
	Location   TemplateLocation `json:"location"`
}

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

type Text = xml.Text

type TextAlignment = xml.TextAlignment

type TextNode struct {
	Content string
}

type Token struct {
	Type  TokenType
	Value string
}

type TokenKind string

type TokenType int

type UnaryOpNode struct {
	Operator string
	Operand  ExpressionNode
}

type UnderlineStyle = xml.UnderlineStyle

type UnlessNode struct {
	Condition ExpressionNode
	ThenBody  []ControlStructure
	ElseBody  []ControlStructure
}

type ValidateTemplateInput struct {
	DocxBytes          []byte           `json:"-"`
	TemplateRevisionID string           `json:"templateRevisionId,omitempty"`
	Strict             bool             `json:"strict,omitempty"`
	IncludeWarnings    bool             `json:"includeWarnings,omitempty"`
	MaxIssues          int              `json:"maxIssues,omitempty"` // 0 = unlimited
	Schema             ValidationSchema `json:"schema"`
}

type ValidateTemplateResult struct {
	Valid           bool                     `json:"valid"`
	Summary         StencilValidationSummary `json:"summary"`
	Issues          []StencilValidationIssue `json:"issues"`
	IssuesTruncated bool                     `json:"issuesTruncated"`
	Metadata        StencilMetadata          `json:"metadata"`
}

type ValidateTemplateSyntaxInput struct {
	DocxBytes          []byte `json:"-"`
	TemplateRevisionID string `json:"templateRevisionId,omitempty"`
	MaxIssues          int    `json:"maxIssues,omitempty"` // 0 = unlimited
}

type ValidateTemplateSyntaxResult struct {
	Valid           bool                     `json:"valid"`
	Summary         StencilValidationSummary `json:"summary"`
	Issues          []StencilValidationIssue `json:"issues"`
	IssuesTruncated bool                     `json:"issuesTruncated"`
	Metadata        StencilMetadata          `json:"metadata"`
}

type ValidationSchema struct {
	Fields    []FieldDefinition    `json:"fields"`
	Functions []FunctionDefinition `json:"functions"`
}

type VariableNode struct {
	Name string
}

type VerticalAlign = xml.VerticalAlign

type Width = xml.Width

type XMLElement struct {
	Type    string       // "element", "text", or "chardata"
	Name    xml.Name     // element name (for type="element")
	Attrs   []xml.Attr   // attributes (for type="element")
	Content []XMLElement // child elements (for type="element")
	Text    string       // text content (for type="text" or "chardata")
}

type XMLFragment struct {
	Elements []XMLElement
}