@broadpaper/core 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,2878 @@
+import { z } from 'zod';
+import { Draft, Patch } from 'immer';
+
+type TextAlign = "left" | "center" | "right" | "justify";
+type VerticalAlign = "top" | "middle" | "bottom";
+type BorderStyle = "solid" | "dashed" | "dotted" | "none";
+interface Spacing {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+interface BorderSpec {
+    width?: number;
+    style?: BorderStyle;
+    color?: ColorValue;
+    radius?: number;
+    /** Which sides to draw. Defaults to all. */
+    sides?: Array<"top" | "right" | "bottom" | "left">;
+}
+/**
+ * Per-instance style overrides. Every field is optional; unspecified values
+ * cascade from the document styles and then the theme.
+ */
+interface BlockStyle {
+    /** Named document text style this block inherits from (e.g. "h1", "body"). */
+    textStyle?: string;
+    fontFamily?: FontValue;
+    fontSize?: number;
+    fontWeight?: number | "normal" | "bold";
+    fontStyle?: "normal" | "italic";
+    lineHeight?: number;
+    letterSpacing?: number;
+    textTransform?: "none" | "uppercase" | "lowercase" | "capitalize";
+    textAlign?: TextAlign;
+    verticalAlign?: VerticalAlign;
+    color?: ColorValue;
+    background?: ColorValue;
+    padding?: Spacing;
+    margin?: Spacing;
+    border?: BorderSpec;
+    /** Width as px number or percentage string ("50%"). */
+    width?: number | string;
+    height?: number;
+    /** Horizontal placement of a fixed-width block inside its column. */
+    align?: "left" | "center" | "right";
+    opacity?: number;
+}
+/** Fully resolved style: every token replaced, every text value present. */
+interface ResolvedStyle {
+    fontFamily: string;
+    fontSize: number;
+    fontWeight: number | "normal" | "bold";
+    fontStyle: "normal" | "italic";
+    lineHeight: number;
+    letterSpacing: number;
+    textTransform: "none" | "uppercase" | "lowercase" | "capitalize";
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    color: string;
+    background?: string;
+    padding: Required<Spacing>;
+    margin: Required<Spacing>;
+    border?: {
+        width: number;
+        style: BorderStyle;
+        color: string;
+        radius: number;
+        sides: Array<"top" | "right" | "bottom" | "left">;
+    };
+    width?: number | string;
+    height?: number;
+    align?: "left" | "center" | "right";
+    opacity?: number;
+}
+
+/**
+ * BroadPaper document format — schemaVersion 1.
+ *
+ * These types describe the saved JSON template. They are a public API:
+ * every change must be additive or go through a migration in `schema/migrate.ts`.
+ *
+ * Units: page geometry (size, margins, region heights) is stored in millimetres
+ * because that is how people think about paper. All other lengths (font sizes,
+ * padding, borders) are CSS pixels at 96 dpi.
+ */
+
+declare const CURRENT_SCHEMA_VERSION: 1;
+type SchemaVersion = typeof CURRENT_SCHEMA_VERSION;
+/** A colour literal (`#RRGGBB`, `rgba(...)`) or a theme token reference (`$colors.primary`). */
+type ColorValue = string;
+/** A font family literal (`"Inter"`) or a theme token reference (`$typography.headingFont`). */
+type FontValue = string;
+/** A theme token reference. Always starts with `$`. */
+type TokenRef = `$${string}`;
+type PageSizeName = "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid";
+interface CustomPageSize {
+    /** Width in millimetres. */
+    width: number;
+    /** Height in millimetres. */
+    height: number;
+}
+type PageSize = PageSizeName | CustomPageSize;
+type PageOrientation = "portrait" | "landscape";
+interface PageMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface PageRegionSettings {
+    /** Region height in millimetres (0 disables the region). */
+    height: number;
+    /** Use `header.firstPage` / `footer.firstPage` content on page 1. */
+    differentFirstPage: boolean;
+}
+interface PageSettings {
+    size: PageSize;
+    orientation: PageOrientation;
+    margins: PageMargins;
+    header: PageRegionSettings;
+    footer: PageRegionSettings;
+    background?: ColorValue;
+    /** Number of pages to show as the design canvas when the document is empty. */
+    minPages?: number;
+}
+type TextStyleId = "h1" | "h2" | "h3" | "h4" | "body" | "lead" | "caption" | "small" | (string & {});
+interface TextStyle {
+    fontFamily?: FontValue;
+    fontSize?: number;
+    fontWeight?: number | "normal" | "bold";
+    fontStyle?: "normal" | "italic";
+    lineHeight?: number;
+    letterSpacing?: number;
+    textTransform?: "none" | "uppercase" | "lowercase" | "capitalize";
+    color?: ColorValue;
+    marginTop?: number;
+    marginBottom?: number;
+    /** Headings default to keep-with-next. */
+    keepWithNext?: boolean;
+}
+interface TableStyle {
+    fontSize?: number;
+    headerBackground?: ColorValue;
+    headerColor?: ColorValue;
+    headerFontWeight?: number | "normal" | "bold";
+    borderColor?: ColorValue;
+    borderWidth?: number;
+    /** "all" draws a grid, "horizontal" draws row rules, "none" draws no lines. */
+    borders?: "all" | "horizontal" | "outer" | "none";
+    zebraBackground?: ColorValue;
+    cellPaddingX?: number;
+    cellPaddingY?: number;
+}
+interface CardStyle {
+    background?: ColorValue;
+    borderColor?: ColorValue;
+    borderWidth?: number;
+    borderRadius?: number;
+    padding?: number;
+    shadow?: boolean;
+}
+interface DocumentStyles {
+    text: Record<TextStyleId, TextStyle>;
+    table: TableStyle;
+    card: CardStyle;
+    link: {
+        color?: ColorValue;
+        underline?: boolean;
+    };
+    spacing: {
+        /** Vertical gap between blocks in px. */
+        blockGap: number;
+        /** Default section vertical padding in px. */
+        sectionPadding: number;
+        /** Gap between columns in px. */
+        columnGap: number;
+    };
+}
+/** Structured visibility rule, built by the UI without writing code. */
+interface ConditionRule {
+    /** Left operand: an expression, usually a data path such as `client.isRetired`. */
+    left: string;
+    operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith" | "endsWith" | "in" | "isEmpty" | "isNotEmpty" | "isTrue" | "isFalse";
+    /** Right operand as a literal (string, number, boolean) or an expression string wrapped in `{{ }}`. */
+    right?: string | number | boolean | null;
+}
+interface ConditionGroup {
+    op: "and" | "or";
+    rules: Array<ConditionRule | ConditionGroup>;
+}
+/** A raw expression string or a structured group. Both compile to the expression language. */
+type Condition = string | ConditionGroup;
+type BreakMode = "auto" | "page";
+interface FlowOptions {
+    breakBefore?: BreakMode;
+    breakAfter?: BreakMode;
+    /** Never split this node across pages unless it is taller than a page. */
+    keepTogether?: boolean;
+    /** Keep this node on the same page as the start of the next sibling. */
+    keepWithNext?: boolean;
+    /** Minimum lines/rows to leave at the bottom of a page (orphans). */
+    minOrphans?: number;
+    /** Minimum lines/rows to carry to the next page (widows). */
+    minWidows?: number;
+}
+/**
+ * A node in the document tree. Structural node types are `section`, `row` and
+ * `column`; everything else is a block type resolved through the block registry.
+ */
+interface Node {
+    id: string;
+    type: string;
+    props: Record<string, unknown>;
+    style?: BlockStyle;
+    children?: Node[];
+    visibleWhen?: Condition;
+    flow?: FlowOptions;
+    /** Human label shown in the layer tree. */
+    name?: string;
+    /** A locked node cannot be moved or deleted in the editor. */
+    locked?: boolean;
+}
+interface RegionContent {
+    default: Node[];
+    firstPage?: Node[];
+}
+interface LibraryItem {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    /** A section (or block) subtree to insert. IDs are re-generated on insert. */
+    node: Node;
+    thumbnail?: string;
+}
+interface TemplateSettings {
+    /** BCP-47 locale used for number/date formatting defaults. */
+    locale?: string;
+    /** ISO 4217 currency used when `currency` pipe has no explicit code. */
+    currency?: string;
+    /** IANA time zone used for date formatting. */
+    timeZone?: string;
+    /** Data source ids this template was designed against. */
+    dataSources?: string[];
+}
+interface TemplateMeta {
+    createdAt?: string;
+    updatedAt?: string;
+    author?: string;
+    description?: string;
+    tags?: string[];
+    /** Free-form host metadata. Never interpreted by BroadPaper. */
+    custom?: Record<string, unknown>;
+}
+interface ReportTemplate {
+    schemaVersion: SchemaVersion;
+    id: string;
+    name: string;
+    meta?: TemplateMeta;
+    page: PageSettings;
+    styles: DocumentStyles;
+    header: RegionContent;
+    footer: RegionContent;
+    /** Top-level content: a list of `section` nodes. */
+    body: Node[];
+    library?: LibraryItem[];
+    settings?: TemplateSettings;
+}
+/** A template of any historical schema version. Use `migrateTemplate` before use. */
+interface AnyVersionTemplate {
+    schemaVersion: number;
+    [key: string]: unknown;
+}
+
+/**
+ * Data source schemas supplied by the host application.
+ * BroadPaper knows nothing about the host's domain; everything it shows in the
+ * data panel, validates, and formats is derived from these descriptions.
+ */
+type FieldType = "string" | "number" | "currency" | "percent" | "date" | "datetime" | "boolean" | "image" | "url" | "richtext" | "object" | "array";
+interface FieldSchema {
+    type: FieldType;
+    label?: string;
+    description?: string;
+    /** Default display format for the field (e.g. "dd MMM yyyy" for dates, "0.0%" for percent). */
+    format?: string;
+    /** ISO 4217 code for `currency` fields. */
+    currency?: string;
+    /** Child fields for `object`. */
+    fields?: Record<string, FieldSchema>;
+    /** Item schema for `array`. */
+    itemSchema?: FieldSchema;
+    /** Allowed values for enumerated strings. */
+    enum?: Array<string | number>;
+    /** Example value shown in design mode when no sample data is provided. */
+    example?: unknown;
+    /** Marks a field the host guarantees to supply. Bindings to optional fields get a default hint. */
+    required?: boolean;
+}
+interface DataSource {
+    id: string;
+    label: string;
+    description?: string;
+    /** Lucide icon name or inline SVG for the data panel. */
+    icon?: string;
+    schema: Record<string, FieldSchema>;
+}
+/** Runtime data keyed by data source id. */
+type ReportData = Record<string, unknown>;
+/** Values available under `page.*` while rendering a page. */
+interface PageContext {
+    number: number;
+    total: number;
+}
+
+/**
+ * Brand theme supplied by the host. A template references theme values via
+ * tokens (`$colors.primary`) so one template renders under any brand.
+ */
+interface ThemeFontFace {
+    family: string;
+    /** URL(s) to the font file(s). `data:` URLs are supported for fully offline rendering. */
+    src: string | string[];
+    weight?: number | string;
+    style?: "normal" | "italic";
+    display?: "auto" | "block" | "swap";
+}
+interface ThemeTypography {
+    headingFont: string;
+    bodyFont: string;
+    monoFont?: string;
+    /** Base body font size in px. */
+    baseFontSize?: number;
+    /** Multiplier used for default heading sizes. */
+    headingScale?: number;
+    headingWeight?: number | "normal" | "bold";
+    bodyWeight?: number | "normal" | "bold";
+    lineHeight?: number;
+    headingLetterSpacing?: number;
+}
+interface ThemeColors {
+    primary: string;
+    secondary: string;
+    accent: string;
+    text: string;
+    mutedText: string;
+    surface: string;
+    background: string;
+    border: string;
+    success?: string;
+    warning?: string;
+    danger?: string;
+    /** Ordered palette for chart series. */
+    chart?: string[];
+    /** Additional named colours a host wants available as `$colors.<name>`. */
+    [name: string]: string | string[] | undefined;
+}
+interface ThemeTableDefaults {
+    headerBackground?: string;
+    headerColor?: string;
+    zebraBackground?: string;
+    borderColor?: string;
+}
+interface Theme {
+    id: string;
+    name: string;
+    /** Primary logo URL (SVG/PNG). Exposed as `$logo` and `theme.logo`. */
+    logo?: string;
+    /** Logo variant for dark backgrounds. */
+    logoDark?: string;
+    logoAlt?: string;
+    typography: ThemeTypography;
+    colors: ThemeColors;
+    fonts?: ThemeFontFace[];
+    /** Default border radius in px for cards, buttons and images. */
+    radius?: number;
+    table?: ThemeTableDefaults;
+    /**
+     * Free-form values exposed to expressions as `theme.meta.*`
+     * (e.g. company name, address, regulatory footer).
+     */
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * Constrained rich-text model. This is what is stored in the template — never HTML.
+ * It is intentionally small: paragraphs and lists containing inline runs with a
+ * fixed set of marks, plus inline data tokens.
+ */
+interface TextMarks {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    code?: boolean;
+    /** Colour literal or theme token. */
+    color?: string;
+    /** A hyperlink. Only `http(s):` and `mailto:` are rendered. May contain `{{ }}` tokens. */
+    link?: string;
+}
+interface TextRun {
+    type: "text";
+    text: string;
+    marks?: TextMarks;
+}
+interface TokenRun {
+    type: "token";
+    /** Expression, e.g. `client.firstName | upper`. */
+    expr: string;
+    marks?: TextMarks;
+    /** Filled by the resolver: evaluated display value. */
+    value?: string;
+    /** Filled by the resolver: human label for design-mode chips. */
+    label?: string;
+    /** Filled by the resolver: expression depends on `page.*` and is evaluated per page. */
+    deferred?: boolean;
+}
+interface BreakRun {
+    type: "break";
+}
+type InlineNode = TextRun | TokenRun | BreakRun;
+interface Paragraph {
+    type: "paragraph";
+    content: InlineNode[];
+    align?: "left" | "center" | "right" | "justify";
+}
+interface ListItem {
+    type: "listItem";
+    content: Paragraph[];
+}
+interface List {
+    type: "bulletList" | "orderedList";
+    content: ListItem[];
+}
+type BlockNode = Paragraph | List;
+interface RichTextDoc {
+    type: "doc";
+    content: BlockNode[];
+}
+declare function createParagraph(text?: string, marks?: TextMarks): Paragraph;
+declare function createRichText(text?: string): RichTextDoc;
+/** Builds a rich text document from a template string containing `{{ expr }}` tokens. */
+declare function richTextFromTemplate(template: string): RichTextDoc;
+declare function inlineFromTemplate(text: string): InlineNode[];
+/** Plain-text projection used for search, validation messages and layer labels. */
+declare function richTextToPlain(doc: RichTextDoc | undefined, tokenText?: (expr: string) => string): string;
+declare function inlineToPlain(content: InlineNode[], tokenText: (expr: string) => string): string;
+/** Every token expression used in a rich text document, in order. */
+declare function richTextTokens(doc: RichTextDoc | undefined): string[];
+/** Extracts `{{ expr }}` expressions from a plain template string. */
+declare function extractTemplateTokens(text: string | undefined): string[];
+declare function isRichTextDoc(value: unknown): value is RichTextDoc;
+
+/**
+ * Abstract syntax tree for the BroadPaper expression language.
+ *
+ * The language is intentionally small and has no way to execute host code:
+ *   paths        client.firstName   holdings[0].name   item.value
+ *   literals     "text"  'text'  12.5  true  false  null
+ *   operators    == != < <= > >= + - * / % and or not in ?:
+ *   pipes        value | currency:"GBP" | default:"—"
+ *   functions    sum(holdings.value)  count(items)  coalesce(a, b)
+ */
+type Expr = {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "path";
+    segments: PathSegment[];
+} | {
+    kind: "unary";
+    op: "not" | "-";
+    arg: Expr;
+} | {
+    kind: "binary";
+    op: BinaryOp;
+    left: Expr;
+    right: Expr;
+} | {
+    kind: "conditional";
+    test: Expr;
+    then: Expr;
+    else: Expr;
+} | {
+    kind: "call";
+    name: string;
+    args: Expr[];
+} | {
+    kind: "pipe";
+    input: Expr;
+    name: string;
+    args: Expr[];
+} | {
+    kind: "array";
+    items: Expr[];
+};
+type PathSegment = {
+    kind: "prop";
+    name: string;
+} | {
+    kind: "index";
+    index: number;
+};
+type BinaryOp = "==" | "!=" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "and" | "or" | "in";
+declare function pathToString(segments: PathSegment[]): string;
+/** Serialises an AST back to canonical source text. */
+declare function exprToString(e: Expr): string;
+/** Collects every path referenced by an expression (for validation and dependency tracking). */
+declare function collectPaths(e: Expr, out?: PathSegment[][]): PathSegment[][];
+
+declare class ExpressionError extends Error {
+    readonly position: number;
+    readonly source: string;
+    constructor(message: string, position: number, source: string);
+}
+type Token = {
+    type: "num";
+    value: number;
+    pos: number;
+} | {
+    type: "str";
+    value: string;
+    pos: number;
+} | {
+    type: "ident";
+    value: string;
+    pos: number;
+} | {
+    type: "op";
+    value: string;
+    pos: number;
+} | {
+    type: "eof";
+    pos: number;
+};
+declare function tokenize(src: string): Token[];
+/** Parses an expression. Results are cached; the AST must be treated as immutable. */
+declare function parseExpression(src: string): Expr;
+/** Returns the parse error for an expression, or null if it parses. */
+declare function checkExpressionSyntax(src: string): ExpressionError | null;
+
+/**
+ * Formatting pipes. Every pipe is a pure function of (value, args, context).
+ * They never throw for bad input: unformattable values pass through as text so
+ * a report never fails to render because one field was unexpectedly empty.
+ */
+interface FormatContext {
+    locale: string;
+    currency: string;
+    timeZone?: string;
+    /** Fixed "now" for deterministic output (tests, reproducible PDFs). */
+    now?: Date;
+}
+type PipeFn = (value: unknown, args: unknown[], ctx: FormatContext) => unknown;
+interface PipeDefinition {
+    name: string;
+    description: string;
+    /** Output type used by the static type checker. "same" keeps the input type. */
+    returns: "string" | "number" | "boolean" | "same" | "array";
+    /** Argument descriptions shown in the editor. */
+    args?: Array<{
+        name: string;
+        type: "string" | "number" | "boolean" | "any";
+        optional?: boolean;
+        description?: string;
+    }>;
+    /** Input types this pipe is meant for (documentation and editor suggestions only). */
+    accepts?: string[];
+    fn: PipeFn;
+}
+declare function toNumber(value: unknown): number | null;
+declare function toDate(value: unknown): Date | null;
+declare function isEmptyValue(value: unknown): boolean;
+declare function toDisplayString(value: unknown): string;
+/**
+ * Date pattern tokens (a pragmatic subset of Unicode/date-fns tokens):
+ * yyyy yy MMMM MMM MM M dd d EEEE EEE HH H hh h mm ss a
+ */
+declare function formatDatePattern(date: Date, pattern: string, ctx: FormatContext): string;
+declare function formatDate(value: unknown, pattern: string | undefined, ctx: FormatContext, withTime?: boolean): string;
+declare function formatCurrency(value: unknown, currency: string | undefined, decimals: number | undefined, ctx: FormatContext): string;
+declare function formatNumber(value: unknown, decimals: number | undefined, ctx: FormatContext): string;
+declare function formatPercent(value: unknown, decimals: number | undefined, ctx: FormatContext, alreadyScaled?: boolean): string;
+declare const PIPES: Record<string, PipeDefinition>;
+declare function getField(obj: unknown, path: string): unknown;
+declare function compareValues(a: unknown, b: unknown): number;
+declare function looseEquals(a: unknown, b: unknown): boolean;
+
+/**
+ * A lexical scope chain. Lookups walk from the innermost scope outwards, so a
+ * repeater's `item` shadows a data source called `item` (and we warn about that
+ * in validation).
+ */
+declare class Scope {
+    private readonly vars;
+    private readonly parent?;
+    constructor(vars: Record<string, unknown>, parent?: Scope | undefined);
+    lookup(name: string): {
+        found: boolean;
+        value: unknown;
+    };
+    child(vars: Record<string, unknown>): Scope;
+    /** Names visible in this scope (innermost first, deduplicated). */
+    names(): string[];
+}
+interface EvalContext {
+    scope: Scope;
+    format: FormatContext;
+    /** Optional sink for non-fatal problems encountered during evaluation. */
+    onWarning?: (message: string, expr?: string) => void;
+}
+declare const FUNCTION_NAMES: string[];
+declare function truthy(v: unknown): boolean;
+/**
+ * Safe property access: only own enumerable data properties, never prototype
+ * members, never functions, never symbols.
+ */
+declare function readProperty(obj: unknown, name: string): unknown;
+declare function resolvePath(segments: PathSegment[], scope: Scope): {
+    found: boolean;
+    value: unknown;
+};
+declare function evaluateAst(e: Expr, ctx: EvalContext): unknown;
+/** Evaluates an expression string in a scope. Never throws for runtime data problems. */
+declare function evaluate(src: string, ctx: EvalContext): unknown;
+/** Evaluates to a boolean using report truthiness rules. */
+declare function evaluateCondition(src: string, ctx: EvalContext): boolean;
+/** Evaluates to display text. */
+declare function evaluateText(src: string, ctx: EvalContext): string;
+interface TemplateSegment {
+    kind: "text" | "token";
+    text: string;
+    /** Present for tokens: the expression source. */
+    expr?: string;
+}
+/** Splits `Hello {{ client.firstName }}` into text/token segments. */
+declare function splitTemplate(template: string): TemplateSegment[];
+/** Interpolates `{{ expr }}` tokens in a string. */
+declare function interpolate(template: string, ctx: EvalContext): string;
+
+type ValueType = FieldType | "any" | "null" | "unknown";
+interface TypeIssue {
+    code: "unknown-root" | "unknown-field" | "unknown-pipe" | "unknown-function" | "syntax" | "type-mismatch" | "not-a-list" | "not-an-object";
+    message: string;
+    /** Character offset when known. */
+    position?: number;
+}
+interface TypeResult {
+    type: ValueType;
+    schema?: FieldSchema;
+    issues: TypeIssue[];
+}
+/**
+ * A static scope describing what names are visible and their schemas.
+ * Mirrors the runtime `Scope` chain.
+ */
+declare class SchemaScope {
+    private readonly vars;
+    private readonly parent?;
+    constructor(vars: Record<string, FieldSchema>, parent?: SchemaScope | undefined);
+    lookup(name: string): FieldSchema | undefined;
+    child(vars: Record<string, FieldSchema>): SchemaScope;
+    entries(): Array<{
+        name: string;
+        schema: FieldSchema;
+        depth: number;
+    }>;
+}
+declare const GLOBAL_SCHEMAS: Record<string, FieldSchema>;
+declare function dataSourceSchemas(sources: DataSource[]): Record<string, FieldSchema>;
+declare function createSchemaScope(sources: DataSource[], extraGlobals?: Record<string, FieldSchema>): SchemaScope;
+/** Resolves a path through a schema scope, returning the field schema when known. */
+declare function resolvePathSchema(segments: PathSegment[], scope: SchemaScope): {
+    schema?: FieldSchema;
+    issue?: TypeIssue;
+};
+/** Statically type-checks an expression against a schema scope. */
+declare function typeCheckAst(e: Expr, scope: SchemaScope): TypeResult;
+/** Parses and type-checks an expression string. Syntax errors are returned as issues. */
+declare function typeCheck(src: string, scope: SchemaScope): TypeResult;
+
+/**
+ * Compiles a structured condition (built by the UI) to expression source.
+ * Raw string conditions are returned unchanged.
+ */
+declare function compileCondition(condition: Condition | undefined): string | null;
+declare const CONDITION_OPERATORS: Array<{
+    value: ConditionRule["operator"];
+    label: string;
+    needsValue: boolean;
+    types?: string[];
+}>;
+
+/** The built-in fallback theme. Any missing host theme value falls back to this. */
+declare const DEFAULT_THEME: Theme;
+/** Document styles used by `createTemplate()`. Everything references theme tokens. */
+declare function defaultDocumentStyles(): DocumentStyles;
+
+declare function isTokenRef(value: unknown): value is `$${string}`;
+/**
+ * Resolves a theme token such as `$colors.primary`, `$typography.headingFont`,
+ * `$table.headerBackground` or `$logo`. Returns `undefined` when the token does
+ * not exist in either the theme or the default theme.
+ */
+declare function resolveToken(token: string, theme: Theme): string | undefined;
+/** Returns a concrete value: token references resolved, literals passed through. */
+declare function resolveValue(value: string | undefined, theme: Theme, fallback: string): string;
+interface ThemeTokenInfo {
+    token: `$${string}`;
+    label: string;
+    value: string;
+    group: "colors" | "typography" | "table" | "brand";
+}
+/** Every token a theme exposes, for pickers in the editor. */
+declare function listThemeTokens(theme: Theme): ThemeTokenInfo[];
+declare function humanize(key: string): string;
+/** Merges a partial host theme over the default theme so every value is present. */
+declare function mergeTheme(theme: Partial<Theme> | undefined): Theme;
+/** Reports which theme values the host left undefined (validation warning source). */
+declare function missingThemeValues(theme: Partial<Theme>): string[];
+/** Simple relative-luminance check used to pick readable text on coloured surfaces. */
+declare function isDarkColor(hex: string): boolean;
+declare function textStyleLabel(id: string): string;
+
+interface StyleCascadeInput {
+    theme: Theme;
+    styles: DocumentStyles;
+    /** Document text style to inherit from. Defaults to "body". */
+    textStyle?: string;
+    /** Block definition defaults (lowest priority above document styles). */
+    defaults?: BlockStyle;
+    /** Instance overrides (highest priority). */
+    overrides?: BlockStyle;
+    /** When false, instance overrides are ignored (host permission). */
+    allowOverrides?: boolean;
+}
+/**
+ * Resolves the style cascade for one block:
+ *   theme defaults → document text style → block definition defaults → instance overrides.
+ * Output contains only concrete values; renderers never see tokens.
+ */
+declare function resolveStyle(input: StyleCascadeInput): ResolvedStyle;
+/** Converts a resolved style to inline CSS declarations (used by every renderer). */
+declare function styleToCss(s: ResolvedStyle, opts?: {
+    text?: boolean;
+    box?: boolean;
+}): Record<string, string>;
+declare function cssText(css: Record<string, string | number | undefined>): string;
+
+/**
+ * A tiny virtual node model. Block renderers return VNodes so the same render
+ * code produces DOM in the editor, DOM in the preview, DOM in the PDF service,
+ * and HTML strings in tests — without any framework.
+ */
+type VChild = VNode | string | number | null | undefined | false | VChild[];
+interface VNode {
+    tag: string;
+    props: VProps;
+    children: Array<VNode | string>;
+    /** "svg" for SVG namespace elements. Inferred from the tag when omitted. */
+    ns?: "svg";
+}
+interface VProps {
+    class?: string | Array<string | false | null | undefined>;
+    style?: string | Record<string, string | number | undefined>;
+    /** Data attributes are passed as `data-*` keys. */
+    [attr: string]: string | number | boolean | undefined | null | Array<string | false | null | undefined> | Record<string, string | number | undefined>;
+}
+declare function h(tag: string, props?: VProps | null, ...children: VChild[]): VNode;
+declare function isVNode(v: unknown): v is VNode;
+declare function classNames(value: VProps["class"]): string;
+declare function styleString(value: VProps["style"]): string;
+declare function escapeHtml(s: string): string;
+/** Serialises a VNode tree to an HTML string. Attribute values are always escaped. */
+declare function toHtml(node: VNode | string | Array<VNode | string>): string;
+/** Depth-first walk. Return false from the visitor to stop descending. */
+declare function walkVNodes(node: VNode, visit: (n: VNode) => boolean | void): void;
+
+type ResolvedRole = "section" | "row" | "column" | "block";
+interface ResolvedFlow {
+    breakBefore: "auto" | "page";
+    breakAfter: "auto" | "page";
+    keepTogether: boolean;
+    keepWithNext: boolean;
+    split: SplitMode;
+    minOrphans: number;
+    minWidows: number;
+}
+/**
+ * A node after resolution: every expression evaluated, every repeater expanded,
+ * every conditional decided, every style concrete. This is what the measurer,
+ * paginator and renderers consume. It is plain data and fully serialisable
+ * (which is how the PDF service receives it).
+ */
+interface ResolvedNode {
+    /** Unique instance key. Repeater iterations get `${nodeId}@${index}` suffixes. */
+    key: string;
+    /** Template node id this instance came from. */
+    nodeId: string;
+    type: string;
+    role: ResolvedRole;
+    /** Evaluated props (binding props replaced by their values). */
+    props: Record<string, unknown>;
+    /** Original template props (for design-mode chips and inline editing). */
+    raw: Record<string, unknown>;
+    style: ResolvedStyle;
+    flow: ResolvedFlow;
+    children: ResolvedNode[];
+    bindings: Record<string, BindingInfo>;
+    /** Interpolated `template` props as segments (design mode renders tokens as chips). */
+    textSegments: Record<string, ResolvedSegment[]>;
+    /** Resolved rich text props. */
+    richText: Record<string, RichTextDoc>;
+    /** For rows: column spans in twelfths. */
+    layout?: {
+        columns: number[];
+    };
+    /** For columns: span in twelfths. */
+    span?: number;
+    /** Repeater metadata for iterations. */
+    iteration?: {
+        index: number;
+        count: number;
+        alias: string;
+    };
+    /** Human label for the layer tree / breadcrumbs. */
+    label?: string;
+    /** True in design mode for placeholder content (e.g. an empty repeater). */
+    placeholder?: boolean;
+    /** Node is locked in the editor. */
+    locked?: boolean;
+    /** True if any prop references `page.*` (rendered per page). */
+    pageDependent?: boolean;
+}
+interface ResolvedSegment extends TemplateSegment {
+    /** Evaluated value for tokens (undefined when page-dependent). */
+    value?: string;
+    /** Human label for the chip. */
+    label?: string;
+    /** Deferred: evaluated at render time with the page context. */
+    deferred?: boolean;
+}
+interface ResolvedRegion {
+    /** Sections for regular pages. */
+    default: ResolvedNode[];
+    /** Sections for the first page (only when differentFirstPage). */
+    firstPage?: ResolvedNode[];
+}
+interface ResolvedDocument {
+    body: ResolvedNode[];
+    header: ResolvedRegion;
+    footer: ResolvedRegion;
+    /** Warnings collected during resolution (unknown fields, bad expressions...). */
+    warnings: Array<{
+        message: string;
+        nodeId?: string;
+        expr?: string;
+    }>;
+    mode: "design" | "preview";
+}
+declare const DEFAULT_PAGE_CONTEXT: PageContext;
+
+type IssueSeverity = "error" | "warning" | "info";
+type IssueCode = "schema-invalid" | "unknown-block" | "license-required" | "unknown-binding" | "invalid-expression" | "type-mismatch" | "invalid-condition" | "missing-collection" | "missing-required" | "missing-theme-token" | "missing-theme-value" | "unsupported-font" | "invalid-url" | "invalid-image" | "empty-content" | "empty-value" | "region-overflow" | "layout-invalid" | "scope-shadowing" | "custom";
+/**
+ * Which question an issue answers.
+ *
+ * `template` issues are defects in the design itself: they are true for every
+ * client the report is ever run for, and the designer has to fix them.
+ * `output` issues are true only of the data in front of you — a field this
+ * particular client has not filled in. Both matter, but conflating them makes
+ * the first kind unfindable and the second kind look like the designer's fault.
+ */
+type IssueSource = "template" | "output";
+interface Issue {
+    severity: IssueSeverity;
+    code: IssueCode;
+    message: string;
+    /** Defaults to "template". */
+    source?: IssueSource;
+    /** Node id the issue belongs to, when applicable. */
+    nodeId?: string;
+    /** Prop path on that node. */
+    prop?: string;
+    /** Region: body, header, footer, library. */
+    region?: "body" | "header" | "footer" | "library" | "document";
+    /** Optional machine-readable detail. */
+    detail?: Record<string, unknown>;
+}
+declare function issue(severity: IssueSeverity, code: IssueCode, message: string, extra?: Partial<Issue>): Issue;
+
+type BlockCategory = "content" | "layout" | "data" | "visualisation" | "custom" | "structure";
+type LicenseTier = "community" | "pro" | "enterprise";
+type SplitMode = "none" | "lines" | "rows" | "children";
+type RenderMode = "design" | "preview";
+interface InspectorFieldBase {
+    /** Property name on `props` this field edits. Supports dot paths (`series.color`). */
+    prop: string;
+    label: string;
+    /**
+     * Help text under the control. A function when the useful wording depends on
+     * the block's other settings — a table's row alias is named by the designer,
+     * so "use it like `row.name`" is wrong for every table that renamed it.
+     */
+    description?: string | ((props: Record<string, unknown>) => string);
+    /** Show only when the predicate passes. */
+    when?: (props: Record<string, unknown>) => boolean;
+    /** Take a full row in a two-column inspector grid. */
+    fullWidth?: boolean;
+}
+type SelectOption = {
+    value: string | number | boolean;
+    label: string;
+    icon?: string;
+    description?: string;
+};
+type InspectorField = (InspectorFieldBase & {
+    kind: "text";
+    placeholder?: string;
+    allowTokens?: boolean;
+}) | (InspectorFieldBase & {
+    kind: "textarea";
+    placeholder?: string;
+    rows?: number;
+    allowTokens?: boolean;
+}) | (InspectorFieldBase & {
+    kind: "richtext";
+}) | (InspectorFieldBase & {
+    kind: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+}) | (InspectorFieldBase & {
+    kind: "toggle";
+}) | (InspectorFieldBase & {
+    kind: "select";
+    options?: SelectOption[];
+    optionsFrom?: (props: Record<string, unknown>) => SelectOption[];
+}) | (InspectorFieldBase & {
+    kind: "segmented";
+    options: SelectOption[];
+}) | (InspectorFieldBase & {
+    kind: "color";
+    allowTransparent?: boolean;
+}) | (InspectorFieldBase & {
+    kind: "font";
+}) | (InspectorFieldBase & {
+    kind: "textStyle";
+}) | (InspectorFieldBase & {
+    kind: "binding";
+    valueType?: FieldType | FieldType[];
+    placeholder?: string;
+}) | (InspectorFieldBase & {
+    kind: "collection";
+    placeholder?: string;
+}) | (InspectorFieldBase & {
+    kind: "expression";
+    placeholder?: string;
+}) | (InspectorFieldBase & {
+    kind: "image";
+    allowBinding?: boolean;
+}) | (InspectorFieldBase & {
+    kind: "condition";
+}) | (InspectorFieldBase & {
+    kind: "columns";
+}) | (InspectorFieldBase & {
+    kind: "series";
+}) | (InspectorFieldBase & {
+    kind: "keyValues";
+}) | (InspectorFieldBase & {
+    kind: "list";
+    itemLabel?: string;
+    fields: InspectorField[];
+    /**
+     * One line describing a collapsed item. Without it the list falls back to
+     * whatever field looks like a name, which for a table's conditional
+     * formatting rules meant showing the column id — "c5" — to a person who
+     * has never seen a column id and has no way to look one up.
+     */
+    itemSummary?: (item: Record<string, unknown>, index: number, props: Record<string, unknown>) => string;
+}) | (InspectorFieldBase & {
+    kind: "custom";
+    component: InspectorComponent;
+});
+/**
+ * Framework-neutral mount adapter for custom inspector UIs. `@broadpaper/react`
+ * and `@broadpaper/angular` provide helpers that produce one from a component.
+ */
+interface InspectorComponent {
+    mount(element: HTMLElement, api: InspectorApi): void;
+    update?(api: InspectorApi): void;
+    unmount?(element: HTMLElement): void;
+}
+interface InspectorApi {
+    value: unknown;
+    props: Record<string, unknown>;
+    node: Node;
+    setValue(value: unknown): void;
+    setProps(patch: Record<string, unknown>): void;
+    dataSources: DataSource[];
+    schemaScope: SchemaScope;
+    theme: Theme;
+}
+interface InspectorSection {
+    title: string;
+    fields: InspectorField[];
+    collapsed?: boolean;
+    when?: (props: Record<string, unknown>) => boolean;
+}
+/** Which built-in style groups the inspector shows for a block. */
+type StyleGroup = "textStyle" | "typography" | "alignment" | "spacing" | "border" | "background" | "size" | "flow";
+type BindingKind = 
+/** A single expression yielding a value. */
+"value"
+/** An expression yielding an array. */
+ | "collection"
+/** A plain string that may contain `{{ }}` tokens. */
+ | "template"
+/** A rich text document containing inline tokens. */
+ | "richtext"
+/** A structured or string condition. */
+ | "condition"
+/** A list of objects that contain nested bindings (see `items`). Not evaluated itself. */
+ | "list";
+interface BindingSpec {
+    prop: string;
+    kind: BindingKind;
+    valueType?: FieldType | FieldType[];
+    /** Nested bindings inside list props (e.g. table columns). */
+    items?: BindingSpec[];
+    /** For collections: props on this block that are evaluated per item (e.g. table column values). */
+    scoped?: BindingSpec[];
+    /** Prop holding the alias name introduced into scope for per-item bindings. */
+    alias?: string;
+    /**
+     * The expression is evaluated per item of the block's collection by the block's
+     * own `resolve` hook (e.g. table column values). The resolver leaves it alone;
+     * validation checks it in the item scope.
+     */
+    perItem?: boolean;
+}
+interface BindingInfo {
+    prop: string;
+    kind: BindingKind;
+    expr: string;
+    /** Human label such as "Client › First name". */
+    label: string;
+    type?: FieldType | "unknown";
+}
+interface ContainerSpec {
+    /** What children this node accepts: block types, or a wildcard group. */
+    accepts: Array<string | "@blocks" | "@rows" | "@columns" | "@sections">;
+    min?: number;
+    max?: number;
+    /** Repeat children once per item of the collection in `collectionProp`. */
+    repeat?: {
+        collectionProp: string;
+        aliasProp?: string;
+        keepItemTogetherProp?: string;
+        emptyMessageProp?: string;
+        limitProp?: string;
+    };
+    /** Show children only when the condition in `conditionProp` holds. */
+    conditional?: {
+        conditionProp: string;
+        elseChildrenProp?: string;
+    };
+    /** Direction children are laid out in. Default "column". */
+    direction?: "column" | "row";
+}
+interface ResolveHookContext<P> {
+    props: P;
+    node: Node;
+    scope: Scope;
+    mode: RenderMode;
+    theme: Theme;
+    format: FormatContext;
+    evaluate(expr: string): unknown;
+    evaluateIn(expr: string, vars: Record<string, unknown>): unknown;
+    warn(message: string): void;
+}
+interface RenderContext<P = Record<string, unknown>> {
+    node: ResolvedNode;
+    props: P;
+    style: ResolvedStyle;
+    /** Inline CSS for the block root: text + box (padding, border, background). Margin/width are applied by the wrapper. */
+    css: Record<string, string>;
+    theme: Theme;
+    styles: DocumentStyles;
+    mode: RenderMode;
+    h: typeof h;
+    /** Rendered child nodes (containers only). */
+    children: VNode[];
+    page: PageContext;
+    /** Available width in px. */
+    width: number;
+    format: FormatContext;
+    registry: BlockRegistryLike;
+    /** Renders an interpolated string prop; tokens become chips in design mode. */
+    text(prop: string, fallback?: string): VChild[];
+    /** Renders a rich text prop. */
+    richText(prop: string): VChild[];
+    /** Renders a plain string value that may contain tokens (already resolved in preview). */
+    textValue(value: string | undefined): VChild[];
+    /** Metadata about a bound prop (for badges/chips). */
+    binding(prop: string): BindingInfo | undefined;
+    /** Standard attributes for a sub-element the editor should be able to target. */
+    partAttrs(part: string, extra?: VProps): VProps;
+    /** Placeholder shown in design mode for empty content. */
+    placeholder(text: string, extra?: VProps): VNode;
+}
+interface ValidateContext<P> {
+    props: P;
+    node: Node;
+    schemaScope: SchemaScope;
+    dataSources: DataSource[];
+    theme: Theme;
+    /** Type-checks an expression and returns its issues (already prefixed with the node). */
+    checkExpression(expr: string, prop: string): Issue[];
+}
+interface BlockRegistryLike {
+    get(type: string): BlockDefinition | undefined;
+    has(type: string): boolean;
+}
+interface BlockDefinition<P extends Record<string, unknown> = Record<string, unknown>> {
+    /** Unique type id. Custom blocks should be namespaced: "acme.risk-profile". */
+    type: string;
+    name: string;
+    description?: string;
+    category: BlockCategory;
+    /** Lucide icon name (e.g. "heading") or an inline `<svg>` string. */
+    icon?: string;
+    keywords?: string[];
+    /**
+     * The tier **the host** sells this block in, badged in the palette and
+     * reported by validation when the host has not enabled it.
+     *
+     * It exists so an embedder can put their own blocks behind their own plans.
+     * BroadPaper's built-in blocks never set it, and must not: the two BroadPaper
+     * licences unlock identical software, and nothing in this SDK reads an
+     * entitlement to decide what to allow. Chart, Table and Repeater carried
+     * `"pro"` for a while, which said the opposite of what we sell.
+     */
+    license?: LicenseTier;
+    /** Do not show in the block palette (structural nodes, deprecated types). */
+    hidden?: boolean;
+    /** Version of the props shape. Bump and implement `migrate` when it changes. */
+    version?: number;
+    defaultProps: P | (() => P);
+    defaultStyle?: BlockStyle;
+    defaultFlow?: FlowOptions;
+    /** Document text style to inherit from ("body", "h1", ...). */
+    defaultTextStyle?: string;
+    inspector?: InspectorSection[];
+    styleGroups?: StyleGroup[];
+    /** Declares props holding expressions. Derived from `inspector` when omitted. */
+    bindings?: BindingSpec[];
+    container?: ContainerSpec;
+    /** How the paginator may split this node. Containers default to "children", leaves to "none". */
+    split?: SplitMode;
+    /**
+     * What the measurer should inspect: "text" reads line boxes, "table" reads rows.
+     * Derived from `split` when omitted.
+     */
+    measure?: "text" | "table" | "none";
+    /** Adjust resolved props after binding resolution (compute derived data, sort, etc.). */
+    resolve?(ctx: ResolveHookContext<P>): P | void;
+    render(ctx: RenderContext<P>): VNode | null;
+    validate?(ctx: ValidateContext<P>): Issue[];
+    migrate?(props: Record<string, unknown>, fromVersion: number): P;
+    canvas?: {
+        /** Enables inline editing of a prop directly on the canvas. */
+        inlineEdit?: {
+            prop: string;
+            kind: "richtext" | "text";
+        };
+        /** Layer-tree label. */
+        label?: (props: P) => string;
+        /** Minimum height in px for the empty design-mode placeholder. */
+        minHeight?: number;
+    };
+}
+/** Identity helper that gives full type inference for custom blocks. */
+declare function defineBlock<P extends Record<string, unknown>>(def: BlockDefinition<P>): BlockDefinition<P>;
+declare function resolveDefaultProps<P extends Record<string, unknown>>(def: BlockDefinition<P>): P;
+
+interface RegistryOptions {
+    /** Licence tiers that are enabled. Blocks above the enabled tier are still rendered but flagged. */
+    enabledTiers?: LicenseTier[];
+}
+/**
+ * The block registry. Built-in blocks and host custom blocks are registered the
+ * same way; there is no privileged path.
+ */
+declare class BlockRegistry {
+    private readonly defs;
+    private readonly listeners;
+    private readonly enabledTiers;
+    constructor(defs?: Array<BlockDefinition<any>>, opts?: RegistryOptions);
+    register<P extends Record<string, unknown>>(def: BlockDefinition<P>): this;
+    /** Replaces an existing definition (used for hot-swapping custom blocks in dev). */
+    replace<P extends Record<string, unknown>>(def: BlockDefinition<P>): this;
+    unregister(type: string): this;
+    get(type: string): BlockDefinition | undefined;
+    has(type: string): boolean;
+    require(type: string): BlockDefinition;
+    list(): BlockDefinition[];
+    /** Blocks shown in the palette, grouped by category, honouring `hidden`. */
+    palette(): BlockDefinition[];
+    isTierEnabled(tier: LicenseTier | undefined): boolean;
+    /** The highest tier required by a set of block types. */
+    requiredTier(types: Iterable<string>): LicenseTier;
+    /** Effective binding specs for a block: explicit `bindings`, else derived from the inspector. */
+    bindingsOf(type: string): BindingSpec[];
+    /** Whether `childType` may be placed inside `parentType`. */
+    accepts(parentType: string, childType: string): boolean;
+    subscribe(fn: () => void): () => void;
+    private emit;
+}
+declare function bindingSpecsFor(def: BlockDefinition<any>): BindingSpec[];
+
+declare const blockStyleSchema: z.ZodObject<{
+    textStyle: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    fontFamily: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    fontSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    fontWeight: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["normal", "bold"]>]>>>;
+    fontStyle: z.ZodOptional<z.ZodOptional<z.ZodEnum<["normal", "italic"]>>>;
+    lineHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    letterSpacing: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    textTransform: z.ZodOptional<z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>>;
+    textAlign: z.ZodOptional<z.ZodOptional<z.ZodEnum<["left", "center", "right", "justify"]>>>;
+    verticalAlign: z.ZodOptional<z.ZodOptional<z.ZodEnum<["top", "middle", "bottom"]>>>;
+    color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    background: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    padding: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        top: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        right: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        bottom: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        left: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    }, {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    }>>>;
+    margin: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        top: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        right: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        bottom: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        left: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    }, {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    }>>>;
+    border: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        style: z.ZodOptional<z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted", "none"]>>>;
+        color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        radius: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        sides: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left"]>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        radius?: number | undefined;
+        color?: string | undefined;
+        style?: "solid" | "dashed" | "dotted" | "none" | undefined;
+        width?: number | undefined;
+        sides?: ("left" | "right" | "top" | "bottom")[] | undefined;
+    }, {
+        radius?: number | undefined;
+        color?: string | undefined;
+        style?: "solid" | "dashed" | "dotted" | "none" | undefined;
+        width?: number | undefined;
+        sides?: ("left" | "right" | "top" | "bottom")[] | undefined;
+    }>>>;
+    width: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>>;
+    height: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    align: z.ZodOptional<z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>>;
+    opacity: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    background?: string | undefined;
+    border?: {
+        radius?: number | undefined;
+        color?: string | undefined;
+        style?: "solid" | "dashed" | "dotted" | "none" | undefined;
+        width?: number | undefined;
+        sides?: ("left" | "right" | "top" | "bottom")[] | undefined;
+    } | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    lineHeight?: number | undefined;
+    color?: string | undefined;
+    padding?: {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    } | undefined;
+    margin?: {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    } | undefined;
+    width?: string | number | undefined;
+    height?: number | undefined;
+    opacity?: number | undefined;
+    textStyle?: string | undefined;
+    fontFamily?: string | undefined;
+    fontSize?: number | undefined;
+    fontWeight?: number | "normal" | "bold" | undefined;
+    fontStyle?: "normal" | "italic" | undefined;
+    letterSpacing?: number | undefined;
+    textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+    textAlign?: "left" | "center" | "right" | "justify" | undefined;
+    verticalAlign?: "top" | "middle" | "bottom" | undefined;
+}, {
+    background?: string | undefined;
+    border?: {
+        radius?: number | undefined;
+        color?: string | undefined;
+        style?: "solid" | "dashed" | "dotted" | "none" | undefined;
+        width?: number | undefined;
+        sides?: ("left" | "right" | "top" | "bottom")[] | undefined;
+    } | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    lineHeight?: number | undefined;
+    color?: string | undefined;
+    padding?: {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    } | undefined;
+    margin?: {
+        left?: number | undefined;
+        right?: number | undefined;
+        top?: number | undefined;
+        bottom?: number | undefined;
+    } | undefined;
+    width?: string | number | undefined;
+    height?: number | undefined;
+    opacity?: number | undefined;
+    textStyle?: string | undefined;
+    fontFamily?: string | undefined;
+    fontSize?: number | undefined;
+    fontWeight?: number | "normal" | "bold" | undefined;
+    fontStyle?: "normal" | "italic" | undefined;
+    letterSpacing?: number | undefined;
+    textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+    textAlign?: "left" | "center" | "right" | "justify" | undefined;
+    verticalAlign?: "top" | "middle" | "bottom" | undefined;
+}>;
+declare const nodeSchema: z.ZodType<Node>;
+declare const pageSettingsSchema: z.ZodObject<{
+    size: z.ZodUnion<[z.ZodEnum<["A4", "A3", "A5", "Letter", "Legal", "Tabloid"]>, z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>]>;
+    orientation: z.ZodEnum<["portrait", "landscape"]>;
+    margins: z.ZodObject<{
+        top: z.ZodNumber;
+        right: z.ZodNumber;
+        bottom: z.ZodNumber;
+        left: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }, {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }>;
+    header: z.ZodObject<{
+        height: z.ZodNumber;
+        differentFirstPage: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        height: number;
+        differentFirstPage: boolean;
+    }, {
+        height: number;
+        differentFirstPage: boolean;
+    }>;
+    footer: z.ZodObject<{
+        height: z.ZodNumber;
+        differentFirstPage: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        height: number;
+        differentFirstPage: boolean;
+    }, {
+        height: number;
+        differentFirstPage: boolean;
+    }>;
+    background: z.ZodOptional<z.ZodString>;
+    minPages: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    header: {
+        height: number;
+        differentFirstPage: boolean;
+    };
+    footer: {
+        height: number;
+        differentFirstPage: boolean;
+    };
+    size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+        width: number;
+        height: number;
+    };
+    orientation: "portrait" | "landscape";
+    margins: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    background?: string | undefined;
+    minPages?: number | undefined;
+}, {
+    header: {
+        height: number;
+        differentFirstPage: boolean;
+    };
+    footer: {
+        height: number;
+        differentFirstPage: boolean;
+    };
+    size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+        width: number;
+        height: number;
+    };
+    orientation: "portrait" | "landscape";
+    margins: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    background?: string | undefined;
+    minPages?: number | undefined;
+}>;
+declare const documentStylesSchema: z.ZodObject<{
+    text: z.ZodRecord<z.ZodString, z.ZodObject<{
+        fontFamily: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        fontSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        fontWeight: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["normal", "bold"]>]>>>;
+        fontStyle: z.ZodOptional<z.ZodOptional<z.ZodEnum<["normal", "italic"]>>>;
+        lineHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        letterSpacing: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        textTransform: z.ZodOptional<z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>>;
+        color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        marginTop: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        marginBottom: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        keepWithNext: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        lineHeight?: number | undefined;
+        color?: string | undefined;
+        fontFamily?: string | undefined;
+        fontSize?: number | undefined;
+        fontWeight?: number | "normal" | "bold" | undefined;
+        fontStyle?: "normal" | "italic" | undefined;
+        letterSpacing?: number | undefined;
+        textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+        keepWithNext?: boolean | undefined;
+        marginTop?: number | undefined;
+        marginBottom?: number | undefined;
+    }, {
+        lineHeight?: number | undefined;
+        color?: string | undefined;
+        fontFamily?: string | undefined;
+        fontSize?: number | undefined;
+        fontWeight?: number | "normal" | "bold" | undefined;
+        fontStyle?: "normal" | "italic" | undefined;
+        letterSpacing?: number | undefined;
+        textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+        keepWithNext?: boolean | undefined;
+        marginTop?: number | undefined;
+        marginBottom?: number | undefined;
+    }>>;
+    table: z.ZodObject<{
+        fontSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        headerBackground: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        headerColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        headerFontWeight: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["normal", "bold"]>]>>>;
+        borderColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        borderWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        borders: z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "horizontal", "outer", "none"]>>>;
+        zebraBackground: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        cellPaddingX: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        cellPaddingY: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        headerBackground?: string | undefined;
+        headerColor?: string | undefined;
+        zebraBackground?: string | undefined;
+        borderColor?: string | undefined;
+        fontSize?: number | undefined;
+        headerFontWeight?: number | "normal" | "bold" | undefined;
+        borderWidth?: number | undefined;
+        borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+        cellPaddingX?: number | undefined;
+        cellPaddingY?: number | undefined;
+    }, {
+        headerBackground?: string | undefined;
+        headerColor?: string | undefined;
+        zebraBackground?: string | undefined;
+        borderColor?: string | undefined;
+        fontSize?: number | undefined;
+        headerFontWeight?: number | "normal" | "bold" | undefined;
+        borderWidth?: number | undefined;
+        borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+        cellPaddingX?: number | undefined;
+        cellPaddingY?: number | undefined;
+    }>;
+    card: z.ZodObject<{
+        background: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        borderColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        borderWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        borderRadius: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        padding: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        shadow: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        background?: string | undefined;
+        borderColor?: string | undefined;
+        padding?: number | undefined;
+        borderWidth?: number | undefined;
+        borderRadius?: number | undefined;
+        shadow?: boolean | undefined;
+    }, {
+        background?: string | undefined;
+        borderColor?: string | undefined;
+        padding?: number | undefined;
+        borderWidth?: number | undefined;
+        borderRadius?: number | undefined;
+        shadow?: boolean | undefined;
+    }>;
+    link: z.ZodObject<{
+        color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        underline: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        color?: string | undefined;
+        underline?: boolean | undefined;
+    }, {
+        color?: string | undefined;
+        underline?: boolean | undefined;
+    }>;
+    spacing: z.ZodObject<{
+        blockGap: z.ZodNumber;
+        sectionPadding: z.ZodNumber;
+        columnGap: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        blockGap: number;
+        sectionPadding: number;
+        columnGap: number;
+    }, {
+        blockGap: number;
+        sectionPadding: number;
+        columnGap: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    text: Record<string, {
+        lineHeight?: number | undefined;
+        color?: string | undefined;
+        fontFamily?: string | undefined;
+        fontSize?: number | undefined;
+        fontWeight?: number | "normal" | "bold" | undefined;
+        fontStyle?: "normal" | "italic" | undefined;
+        letterSpacing?: number | undefined;
+        textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+        keepWithNext?: boolean | undefined;
+        marginTop?: number | undefined;
+        marginBottom?: number | undefined;
+    }>;
+    link: {
+        color?: string | undefined;
+        underline?: boolean | undefined;
+    };
+    table: {
+        headerBackground?: string | undefined;
+        headerColor?: string | undefined;
+        zebraBackground?: string | undefined;
+        borderColor?: string | undefined;
+        fontSize?: number | undefined;
+        headerFontWeight?: number | "normal" | "bold" | undefined;
+        borderWidth?: number | undefined;
+        borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+        cellPaddingX?: number | undefined;
+        cellPaddingY?: number | undefined;
+    };
+    spacing: {
+        blockGap: number;
+        sectionPadding: number;
+        columnGap: number;
+    };
+    card: {
+        background?: string | undefined;
+        borderColor?: string | undefined;
+        padding?: number | undefined;
+        borderWidth?: number | undefined;
+        borderRadius?: number | undefined;
+        shadow?: boolean | undefined;
+    };
+}, {
+    text: Record<string, {
+        lineHeight?: number | undefined;
+        color?: string | undefined;
+        fontFamily?: string | undefined;
+        fontSize?: number | undefined;
+        fontWeight?: number | "normal" | "bold" | undefined;
+        fontStyle?: "normal" | "italic" | undefined;
+        letterSpacing?: number | undefined;
+        textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+        keepWithNext?: boolean | undefined;
+        marginTop?: number | undefined;
+        marginBottom?: number | undefined;
+    }>;
+    link: {
+        color?: string | undefined;
+        underline?: boolean | undefined;
+    };
+    table: {
+        headerBackground?: string | undefined;
+        headerColor?: string | undefined;
+        zebraBackground?: string | undefined;
+        borderColor?: string | undefined;
+        fontSize?: number | undefined;
+        headerFontWeight?: number | "normal" | "bold" | undefined;
+        borderWidth?: number | undefined;
+        borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+        cellPaddingX?: number | undefined;
+        cellPaddingY?: number | undefined;
+    };
+    spacing: {
+        blockGap: number;
+        sectionPadding: number;
+        columnGap: number;
+    };
+    card: {
+        background?: string | undefined;
+        borderColor?: string | undefined;
+        padding?: number | undefined;
+        borderWidth?: number | undefined;
+        borderRadius?: number | undefined;
+        shadow?: boolean | undefined;
+    };
+}>;
+declare const templateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    name: z.ZodString;
+    meta: z.ZodOptional<z.ZodObject<{
+        createdAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        custom: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, "strip", z.ZodTypeAny, {
+        custom?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        author?: string | undefined;
+        description?: string | undefined;
+        tags?: string[] | undefined;
+    }, {
+        custom?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        author?: string | undefined;
+        description?: string | undefined;
+        tags?: string[] | undefined;
+    }>>;
+    page: z.ZodObject<{
+        size: z.ZodUnion<[z.ZodEnum<["A4", "A3", "A5", "Letter", "Legal", "Tabloid"]>, z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+        }, {
+            width: number;
+            height: number;
+        }>]>;
+        orientation: z.ZodEnum<["portrait", "landscape"]>;
+        margins: z.ZodObject<{
+            top: z.ZodNumber;
+            right: z.ZodNumber;
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        }, {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        }>;
+        header: z.ZodObject<{
+            height: z.ZodNumber;
+            differentFirstPage: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            height: number;
+            differentFirstPage: boolean;
+        }, {
+            height: number;
+            differentFirstPage: boolean;
+        }>;
+        footer: z.ZodObject<{
+            height: z.ZodNumber;
+            differentFirstPage: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            height: number;
+            differentFirstPage: boolean;
+        }, {
+            height: number;
+            differentFirstPage: boolean;
+        }>;
+        background: z.ZodOptional<z.ZodString>;
+        minPages: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        header: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        footer: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+            width: number;
+            height: number;
+        };
+        orientation: "portrait" | "landscape";
+        margins: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        };
+        background?: string | undefined;
+        minPages?: number | undefined;
+    }, {
+        header: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        footer: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+            width: number;
+            height: number;
+        };
+        orientation: "portrait" | "landscape";
+        margins: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        };
+        background?: string | undefined;
+        minPages?: number | undefined;
+    }>;
+    styles: z.ZodObject<{
+        text: z.ZodRecord<z.ZodString, z.ZodObject<{
+            fontFamily: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            fontSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            fontWeight: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["normal", "bold"]>]>>>;
+            fontStyle: z.ZodOptional<z.ZodOptional<z.ZodEnum<["normal", "italic"]>>>;
+            lineHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            letterSpacing: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            textTransform: z.ZodOptional<z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>>;
+            color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            marginTop: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            marginBottom: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            keepWithNext: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }>>;
+        table: z.ZodObject<{
+            fontSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            headerBackground: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            headerColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            headerFontWeight: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEnum<["normal", "bold"]>]>>>;
+            borderColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            borderWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            borders: z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "horizontal", "outer", "none"]>>>;
+            zebraBackground: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            cellPaddingX: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            cellPaddingY: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        }, {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        }>;
+        card: z.ZodObject<{
+            background: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            borderColor: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            borderWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            borderRadius: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            padding: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            shadow: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        }, {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        }>;
+        link: z.ZodObject<{
+            color: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            underline: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        }, {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        }>;
+        spacing: z.ZodObject<{
+            blockGap: z.ZodNumber;
+            sectionPadding: z.ZodNumber;
+            columnGap: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        }, {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        text: Record<string, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }>;
+        link: {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        };
+        table: {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        };
+        spacing: {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        };
+        card: {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        };
+    }, {
+        text: Record<string, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }>;
+        link: {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        };
+        table: {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        };
+        spacing: {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        };
+        card: {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        };
+    }>;
+    header: z.ZodObject<{
+        default: z.ZodArray<z.ZodType<Node, z.ZodTypeDef, Node>, "many">;
+        firstPage: z.ZodOptional<z.ZodArray<z.ZodType<Node, z.ZodTypeDef, Node>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    }, {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    }>;
+    footer: z.ZodObject<{
+        default: z.ZodArray<z.ZodType<Node, z.ZodTypeDef, Node>, "many">;
+        firstPage: z.ZodOptional<z.ZodArray<z.ZodType<Node, z.ZodTypeDef, Node>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    }, {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    }>;
+    body: z.ZodArray<z.ZodType<Node, z.ZodTypeDef, Node>, "many">;
+    library: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        node: z.ZodType<Node, z.ZodTypeDef, Node>;
+        thumbnail: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        node: Node;
+        description?: string | undefined;
+        category?: string | undefined;
+        thumbnail?: string | undefined;
+    }, {
+        name: string;
+        id: string;
+        node: Node;
+        description?: string | undefined;
+        category?: string | undefined;
+        thumbnail?: string | undefined;
+    }>, "many">>;
+    settings: z.ZodOptional<z.ZodObject<{
+        locale: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        currency: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        timeZone: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        dataSources: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        currency?: string | undefined;
+        locale?: string | undefined;
+        timeZone?: string | undefined;
+        dataSources?: string[] | undefined;
+    }, {
+        currency?: string | undefined;
+        locale?: string | undefined;
+        timeZone?: string | undefined;
+        dataSources?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    body: Node[];
+    page: {
+        header: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        footer: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+            width: number;
+            height: number;
+        };
+        orientation: "portrait" | "landscape";
+        margins: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        };
+        background?: string | undefined;
+        minPages?: number | undefined;
+    };
+    schemaVersion: 1;
+    name: string;
+    id: string;
+    styles: {
+        text: Record<string, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }>;
+        link: {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        };
+        table: {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        };
+        spacing: {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        };
+        card: {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        };
+    };
+    header: {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    };
+    footer: {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    };
+    meta?: {
+        custom?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        author?: string | undefined;
+        description?: string | undefined;
+        tags?: string[] | undefined;
+    } | undefined;
+    library?: {
+        name: string;
+        id: string;
+        node: Node;
+        description?: string | undefined;
+        category?: string | undefined;
+        thumbnail?: string | undefined;
+    }[] | undefined;
+    settings?: {
+        currency?: string | undefined;
+        locale?: string | undefined;
+        timeZone?: string | undefined;
+        dataSources?: string[] | undefined;
+    } | undefined;
+}, {
+    body: Node[];
+    page: {
+        header: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        footer: {
+            height: number;
+            differentFirstPage: boolean;
+        };
+        size: "A4" | "A3" | "A5" | "Letter" | "Legal" | "Tabloid" | {
+            width: number;
+            height: number;
+        };
+        orientation: "portrait" | "landscape";
+        margins: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        };
+        background?: string | undefined;
+        minPages?: number | undefined;
+    };
+    schemaVersion: 1;
+    name: string;
+    id: string;
+    styles: {
+        text: Record<string, {
+            lineHeight?: number | undefined;
+            color?: string | undefined;
+            fontFamily?: string | undefined;
+            fontSize?: number | undefined;
+            fontWeight?: number | "normal" | "bold" | undefined;
+            fontStyle?: "normal" | "italic" | undefined;
+            letterSpacing?: number | undefined;
+            textTransform?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+            keepWithNext?: boolean | undefined;
+            marginTop?: number | undefined;
+            marginBottom?: number | undefined;
+        }>;
+        link: {
+            color?: string | undefined;
+            underline?: boolean | undefined;
+        };
+        table: {
+            headerBackground?: string | undefined;
+            headerColor?: string | undefined;
+            zebraBackground?: string | undefined;
+            borderColor?: string | undefined;
+            fontSize?: number | undefined;
+            headerFontWeight?: number | "normal" | "bold" | undefined;
+            borderWidth?: number | undefined;
+            borders?: "none" | "all" | "horizontal" | "outer" | undefined;
+            cellPaddingX?: number | undefined;
+            cellPaddingY?: number | undefined;
+        };
+        spacing: {
+            blockGap: number;
+            sectionPadding: number;
+            columnGap: number;
+        };
+        card: {
+            background?: string | undefined;
+            borderColor?: string | undefined;
+            padding?: number | undefined;
+            borderWidth?: number | undefined;
+            borderRadius?: number | undefined;
+            shadow?: boolean | undefined;
+        };
+    };
+    header: {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    };
+    footer: {
+        default: Node[];
+        firstPage?: Node[] | undefined;
+    };
+    meta?: {
+        custom?: Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        author?: string | undefined;
+        description?: string | undefined;
+        tags?: string[] | undefined;
+    } | undefined;
+    library?: {
+        name: string;
+        id: string;
+        node: Node;
+        description?: string | undefined;
+        category?: string | undefined;
+        thumbnail?: string | undefined;
+    }[] | undefined;
+    settings?: {
+        currency?: string | undefined;
+        locale?: string | undefined;
+        timeZone?: string | undefined;
+        dataSources?: string[] | undefined;
+    } | undefined;
+}>;
+interface ParseResult {
+    ok: boolean;
+    template?: ReportTemplate;
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+/** Validates the JSON shape of a template (after migration). */
+declare function parseTemplate(json: unknown): ParseResult;
+
+/** Generates a short, URL-safe unique id. */
+declare function createId(prefix?: string): string;
+/** Tests: makes ids predictable. Pass null to restore random ids. */
+declare function setDeterministicIds(seed: string | null): void;
+
+interface Migration {
+    from: number;
+    to: number;
+    description: string;
+    migrate(template: AnyVersionTemplate): AnyVersionTemplate;
+}
+/**
+ * Ordered list of migrations. Each is a pure function from version N to N+1.
+ * Never edit a shipped migration; add a new one.
+ */
+declare const MIGRATIONS: Migration[];
+interface MigrationResult {
+    template: ReportTemplate;
+    /** Migrations that were applied, in order. */
+    applied: Migration[];
+    fromVersion: number;
+}
+declare class MigrationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Brings a template of any supported version up to the current schema.
+ * Throws `MigrationError` for future versions or missing migration steps.
+ */
+declare function migrateTemplate(input: AnyVersionTemplate | ReportTemplate): MigrationResult;
+declare function needsMigration(input: {
+    schemaVersion?: number;
+}): boolean;
+
+declare function defaultPageSettings(overrides?: Partial<PageSettings>): PageSettings;
+interface CreateTemplateOptions {
+    id?: string;
+    name?: string;
+    page?: Partial<PageSettings>;
+    locale?: string;
+    currency?: string;
+    /** Start with an empty first section. Default true. */
+    withEmptySection?: boolean;
+}
+/** Creates a new, valid, empty template. */
+declare function createTemplate(opts?: CreateTemplateOptions): ReportTemplate;
+interface CreateNodeOptions {
+    id?: string;
+    props?: Record<string, unknown>;
+    style?: BlockStyle;
+    children?: Node[];
+    flow?: FlowOptions;
+    visibleWhen?: string | ConditionGroup;
+    name?: string;
+}
+/** Creates a node of a registered block type with its default props. */
+declare function createNode(registry: BlockRegistry, type: string, opts?: CreateNodeOptions): Node;
+declare function createSection(opts?: CreateNodeOptions): Node;
+declare function createColumn(span: number, children?: Node[], id?: string): Node;
+/** Creates a row with the given twelfths layout, e.g. [6, 6] or [4, 8]. */
+declare function createRow(layout: number[], columns?: Node[][], opts?: CreateNodeOptions): Node;
+declare const ROW_LAYOUTS: Array<{
+    id: string;
+    label: string;
+    layout: number[];
+}>;
+/** Deep-clones a subtree assigning fresh ids (for duplicate/paste/library insert). */
+declare function cloneWithNewIds(node: Node): Node;
+
+/**
+ * Synthesises plausible sample data from a schema. Used in design mode when the
+ * host provides no sample data so tables, charts and KPIs still show something.
+ */
+declare function synthesizeSampleData(sources: DataSource[], opts?: {
+    arrayLength?: number;
+    now?: Date;
+}): ReportData;
+declare function synthesizeValue(schema: FieldSchema, opts?: {
+    arrayLength?: number;
+    now?: Date;
+}, depth?: number, index?: number): unknown;
+/** Human label for a data path, e.g. "Client › First name". */
+declare function labelForPath(segments: PathSegment[], scope: SchemaScope): string;
+declare function humanizeKey(key: string): string;
+
+interface ResolveOptions {
+    template: ReportTemplate;
+    registry: BlockRegistry;
+    theme?: Partial<Theme>;
+    dataSources?: DataSource[];
+    /** Runtime data (preview / PDF). */
+    data?: ReportData;
+    /** Sample data used in design mode when `data` is absent. */
+    sampleData?: ReportData;
+    mode?: RenderMode;
+    /** Fixed clock for deterministic output. */
+    now?: Date;
+    locale?: string;
+    currency?: string;
+    timeZone?: string;
+    /** Iterations shown per repeater in design mode. */
+    designIterations?: number;
+    /** Hard cap on repeater iterations (safety). */
+    maxIterations?: number;
+    /** Whether per-block style overrides are honoured. */
+    allowStyleOverrides?: boolean;
+    /** Design mode: still show nodes whose condition is false (marked as hidden). */
+    designShowHidden?: boolean;
+}
+/**
+ * Resolves a template into a `ResolvedDocument`: evaluates every binding,
+ * expands repeaters, decides conditionals and cascades styles.
+ */
+declare function resolveTemplate(opts: ResolveOptions): ResolvedDocument;
+/** Convenience for tests and tooling: resolves and returns display text of an expression. */
+declare function evaluateToText(expr: string, data: ReportData, format?: Partial<FormatContext>): string;
+
+/**
+ * How an expression should be written where a person is going to read it:
+ * `portfolio.allocation` as "Portfolio › Asset allocation", a piped value with
+ * the filter named after it, a computed one marked with an ƒ.
+ *
+ * The canvas has always drawn its token chips this way. Sharing the same
+ * function with the layer tree, the breadcrumb and the inspector is what stops
+ * one part of the editor calling a thing "Asset allocation" while another calls
+ * it "portfolio.allocation" — the raw path stays available as a tooltip, which
+ * is the right place for it.
+ */
+declare function describeExpression(expr: string, scope: SchemaScope): {
+    label: string;
+    type: BindingInfo["type"];
+};
+/**
+ * Rewrites the readable parts of a label written by a block: `{{ tokens }}` and
+ * bare dotted paths become the names a person would use. Anything that does not
+ * resolve is left exactly as it was, so an unknown path still shows itself
+ * rather than turning into a guess.
+ */
+declare function humaniseLabel(text: string, scope: SchemaScope): string;
+
+/**
+ * Geometry produced by a measurer. All coordinates are in CSS px relative to the
+ * top-left of the *section* the node belongs to (sections are laid out as
+ * independent galleys at the page content width).
+ */
+interface TableRowGeometry {
+    top: number;
+    height: number;
+    kind: "header" | "body" | "footer";
+}
+interface NodeGeometry {
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    /** Text nodes: bottom of each line box (absolute y within the section). */
+    lines?: number[];
+    /** Table nodes: row boxes in document order. */
+    rows?: TableRowGeometry[];
+}
+/** Geometry for every node in one section, keyed by resolved node key. */
+interface SectionGeometry {
+    /** The section's own height. */
+    height: number;
+    width: number;
+    nodes: Record<string, NodeGeometry>;
+}
+/** Geometry for every section in a resolved document, keyed by section key. */
+type GeometryMap = Record<string, SectionGeometry>;
+interface Measurer {
+    /**
+     * Measures the given sections at the given width. Implementations may cache by
+     * section content; the paginator never mutates the result.
+     */
+    measure(sections: ResolvedNode[], width: number): GeometryMap;
+}
+
+/** CSS pixels per millimetre at 96 dpi. */
+declare const PX_PER_MM: number;
+declare const PAGE_SIZES_MM: Record<PageSizeName, {
+    width: number;
+    height: number;
+}>;
+declare function mmToPx(mm: number): number;
+declare function pxToMm(px: number): number;
+declare function pageSizeMm(size: PageSize): {
+    width: number;
+    height: number;
+};
+/** Concrete page geometry in CSS px. */
+interface PageGeometry {
+    width: number;
+    height: number;
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    headerHeight: number;
+    footerHeight: number;
+    /** Width of the content column (page width minus horizontal margins). */
+    contentWidth: number;
+    /** Height available for body content on a regular page. */
+    contentHeight: number;
+    /** Y offset of the body content box from the page top. */
+    contentTop: number;
+    /** Y offset of the header region from the page top. */
+    headerTop: number;
+    /** Y offset of the footer region from the page top. */
+    footerTop: number;
+}
+declare function computePageGeometry(page: PageSettings): PageGeometry;
+
+interface RepeatedHeader {
+    tableKey: string;
+    height: number;
+    left: number;
+    width: number;
+}
+/**
+ * A clip window over a section's full render, placed on a page.
+ * `[from, to)` are y coordinates in the section's own coordinate space.
+ */
+interface PageFragment {
+    sectionKey: string;
+    from: number;
+    to: number;
+    /** Table headers to repeat above the clipped content (tables cut at `from`). */
+    repeatHeaders: RepeatedHeader[];
+    /** Y position of the fragment within the page content box. */
+    y: number;
+    /** Rendered height: (to - from) + repeated header heights. */
+    height: number;
+    /** True when this fragment continues a section started on an earlier page. */
+    continued: boolean;
+    /** True when the section continues on a later page. */
+    continues: boolean;
+}
+interface Page {
+    index: number;
+    number: number;
+    fragments: PageFragment[];
+    /** Whether page 1 variants of header/footer apply. */
+    first: boolean;
+}
+interface LayoutWarning {
+    code: "forced-split" | "region-overflow" | "oversized-header" | "empty-document" | "no-op-break";
+    message: string;
+    nodeId?: string;
+    sectionKey?: string;
+    page?: number;
+}
+interface PagedDocument {
+    pages: Page[];
+    totalPages: number;
+    geometry: PageGeometry;
+    warnings: LayoutWarning[];
+}
+interface PaginateOptions {
+    document: ResolvedDocument;
+    geometry: GeometryMap;
+    page: PageGeometry;
+    /** Show at least this many pages (design canvas). */
+    minPages?: number;
+    /** Geometry for header/footer sections (for overflow warnings). */
+    regionGeometry?: GeometryMap;
+}
+interface BreakCtx {
+    geom: SectionGeometry;
+    pageHeight: number;
+}
+/**
+ * Largest valid break position y with minY < y <= limit inside a list of
+ * siblings, or null if none exists.
+ */
+declare function bestBreak(ctx: BreakCtx, list: ResolvedNode[], limit: number, minY: number): number | null;
+/**
+ * Pure, deterministic pagination. Given resolved sections and their measured
+ * geometry, assigns clip-window fragments to pages.
+ */
+declare function paginate(opts: PaginateOptions): PagedDocument;
+
+interface ValidateOptions {
+    template: ReportTemplate;
+    registry: BlockRegistry;
+    dataSources?: DataSource[];
+    theme?: Partial<Theme>;
+    /** Font families the host guarantees are available (theme fonts are added automatically). */
+    availableFonts?: string[];
+    /** Skip the JSON shape check (already parsed). */
+    skipSchema?: boolean;
+}
+interface ValidationResult {
+    ok: boolean;
+    issues: Issue[];
+    errors: Issue[];
+    warnings: Issue[];
+}
+/**
+ * Statically analyses a template against a registry, data schemas and a theme.
+ * Runs without data and without a DOM, so it can be used server-side before
+ * accepting a template for storage.
+ */
+declare function validateTemplate(opts: ValidateOptions): ValidationResult;
+declare function itemSchemaOf(collectionExpr: string, scope: SchemaScope): FieldSchema | undefined;
+/** URL safety check shared by validation and renderers. */
+declare function isSafeUrl(url: string | undefined, opts?: {
+    allowData?: boolean;
+}): boolean;
+
+interface OutputCheckOptions {
+    /** A document resolved in preview mode against the data you intend to ship. */
+    resolved: ResolvedDocument;
+    registry: BlockRegistry;
+    /** Names the data set in the messages, e.g. "Edge case". */
+    dataLabel?: string;
+    /** Cap on issues returned, so a broken data set cannot flood the UI. */
+    limit?: number;
+}
+/**
+ * Reports what this particular data set does to the report: fields that come out
+ * blank, blocks that render nothing, sections with no content at all.
+ *
+ * This is deliberately separate from `validateTemplate`, which asks whether the
+ * design is sound and never looks at data. A template can be perfectly valid and
+ * still produce "Values as at ." for a client whose review has no end date, and
+ * only one of those two checks can ever tell you so.
+ *
+ * Three things it does not complain about, because complaining would train
+ * people to ignore it:
+ *
+ * - Content hidden by a false condition. A preview resolution has already
+ *   dropped those nodes, so they cannot be reached from here at all.
+ * - An expression that already handles the empty case — a `default:` fallback
+ *   or a conditional. Warning about those would be warning about the fix.
+ * - Zero, false and empty-but-intended lists. `0` is a value; a table with an
+ *   empty message is a designed outcome, not an accident.
+ * - Page-dependent tokens, which have no value until the paginator runs.
+ */
+declare function checkOutput(opts: OutputCheckOptions): Issue[];
+
+type RegionId = "body" | "header" | "header:first" | "footer" | "footer:first";
+declare const REGION_IDS: RegionId[];
+declare function getRegion(template: ReportTemplate, region: RegionId): Node[];
+declare function readRegion(template: ReportTemplate, region: RegionId): Node[];
+interface NodeLocation {
+    region: RegionId;
+    /** Index path from the region root to the node. */
+    path: number[];
+}
+interface NodeEntry {
+    node: Node;
+    parent: Node | null;
+    region: RegionId;
+    path: number[];
+    depth: number;
+    index: number;
+}
+type NodeIndex = Map<string, NodeEntry>;
+/** Builds an id → entry index over the whole template. */
+declare function indexTemplate(template: ReportTemplate): NodeIndex;
+declare function findNode(template: ReportTemplate, id: string): NodeEntry | undefined;
+/** Returns the list that contains the node at `location` and the node's index in it. */
+declare function listAt(template: ReportTemplate, location: NodeLocation): {
+    list: Node[];
+    index: number;
+};
+declare function nodeAt(template: ReportTemplate, location: NodeLocation): Node | undefined;
+/** Ancestor chain from the region root down to (and including) the node. */
+declare function ancestors(index: NodeIndex, id: string): NodeEntry[];
+declare function isDescendant(index: NodeIndex, ancestorId: string, id: string): boolean;
+/** Depth-first walk over every node in the template. */
+declare function walkTemplate(template: ReportTemplate, visit: (node: Node, region: RegionId, parent: Node | null) => void): void;
+declare function countNodes(template: ReportTemplate): number;
+/** Collects all block types used in the template. */
+declare function usedBlockTypes(template: ReportTemplate): Set<string>;
+
+/**
+ * Commands are plain data. Each is applied by a reducer that mutates an immer
+ * draft; immer turns the mutation into immutable structural sharing + patches.
+ */
+type Command = {
+    type: "insertNode";
+    node: Node;
+    at: NodeLocation;
+} | {
+    type: "insertNodes";
+    nodes: Node[];
+    at: NodeLocation;
+} | {
+    type: "removeNodes";
+    ids: string[];
+} | {
+    type: "moveNode";
+    id: string;
+    to: NodeLocation;
+} | {
+    type: "duplicateNode";
+    id: string;
+    newId?: string;
+} | {
+    type: "setProps";
+    id: string;
+    patch: Record<string, unknown>;
+} | {
+    type: "setProp";
+    id: string;
+    path: string;
+    value: unknown;
+} | {
+    type: "setStyle";
+    id: string;
+    patch: BlockStyle | null;
+} | {
+    type: "setFlow";
+    id: string;
+    patch: FlowOptions;
+} | {
+    type: "setVisibleWhen";
+    id: string;
+    condition: Condition | undefined;
+} | {
+    type: "setName";
+    id: string;
+    name: string | undefined;
+} | {
+    type: "setLocked";
+    id: string;
+    locked: boolean;
+} | {
+    type: "setRowLayout";
+    id: string;
+    layout: number[];
+} | {
+    type: "wrapNodes";
+    ids: string[];
+    wrapper: Node;
+} | {
+    type: "replaceNode";
+    id: string;
+    node: Node;
+} | {
+    type: "setPage";
+    patch: Partial<PageSettings>;
+} | {
+    type: "setDocumentStyles";
+    patch: Partial<DocumentStyles>;
+} | {
+    type: "setTextStyle";
+    id: string;
+    patch: TextStyle | null;
+} | {
+    type: "setTemplateName";
+    name: string;
+} | {
+    type: "setSettings";
+    patch: NonNullable<ReportTemplate["settings"]>;
+} | {
+    type: "setRegionFirstPage";
+    region: "header" | "footer";
+    enabled: boolean;
+} | {
+    type: "addLibraryItem";
+    item: LibraryItem;
+} | {
+    type: "removeLibraryItem";
+    id: string;
+} | {
+    type: "replaceTemplate";
+    template: ReportTemplate;
+};
+declare class CommandError extends Error {
+    constructor(message: string);
+}
+/** Applies a command to a template draft. Throws `CommandError` for invalid operations. */
+declare function applyCommand(draft: Draft<ReportTemplate>, cmd: Command): void;
+
+interface HistoryEntry {
+    label: string;
+    patches: Patch[];
+    inversePatches: Patch[];
+    selectionBefore: string[];
+    selectionAfter: string[];
+    at: number;
+    /** Consecutive entries with the same merge key within `mergeWindowMs` are coalesced. */
+    mergeKey?: string;
+}
+interface EditorState {
+    template: ReportTemplate;
+    selection: string[];
+    hoverId: string | null;
+    /** The node being edited inline (rich text), if any. */
+    editingId: string | null;
+    mode: "design" | "preview";
+    zoom: number;
+    activeRegion: RegionId;
+    dirty: boolean;
+    /** Monotonic counter incremented on every document change. */
+    version: number;
+}
+interface DispatchOptions {
+    label?: string;
+    /** Coalesce with the previous history entry sharing this key (typing, slider drags). */
+    mergeKey?: string;
+    /** Do not record in history (e.g. transient drag previews). */
+    skipHistory?: boolean;
+}
+interface EditorStoreOptions {
+    template: ReportTemplate;
+    maxHistory?: number;
+    mergeWindowMs?: number;
+    /** Called after every change, with the new template. */
+    onChange?: (template: ReportTemplate, entry: HistoryEntry | null) => void;
+}
+type Listener = (state: EditorState, prev: EditorState) => void;
+/**
+ * Framework-agnostic editor store. The document is immutable; every change goes
+ * through `dispatch(command)` and is recorded as immer patches for undo/redo.
+ */
+declare class EditorStore {
+    private state;
+    private undoStack;
+    private redoStack;
+    private listeners;
+    private txDepth;
+    private txPatches;
+    private txInverse;
+    private txLabel;
+    private txSelectionBefore;
+    private txSkipHistory;
+    private indexCache;
+    /**
+     * The history entry that was on top of the undo stack when the document was
+     * last saved, so that undoing back to it reports clean again. Identity is the
+     * whole test: undo pops, redo pushes, and a new edit pushes something else.
+     */
+    private savedEntry;
+    /** A change that bypassed history, which no amount of undoing can take back. */
+    private unhistoried;
+    private readonly maxHistory;
+    private readonly mergeWindowMs;
+    private readonly onChange?;
+    constructor(opts: EditorStoreOptions);
+    getState(): EditorState;
+    get template(): ReportTemplate;
+    /** Cached id → node index for the current document version. */
+    index(): NodeIndex;
+    getNode(id: string): Node | undefined;
+    locationOf(id: string): NodeLocation | undefined;
+    subscribe(listener: Listener): () => void;
+    private setState;
+    select(ids: string[] | string | null): void;
+    toggleSelect(id: string): void;
+    hover(id: string | null): void;
+    setEditing(id: string | null): void;
+    setMode(mode: EditorState["mode"]): void;
+    setZoom(zoom: number): void;
+    setActiveRegion(region: RegionId): void;
+    markClean(): void;
+    /** Whether the document differs from the last saved state. */
+    private isDirty;
+    /** Applies one command. Inside a transaction, patches accumulate into one history entry. */
+    dispatch(command: Command, opts?: DispatchOptions): void;
+    /**
+     * Groups every dispatch inside `fn` into a single undo step. Nested
+     * transactions join the outermost one. If `fn` throws, all changes roll back.
+     */
+    transaction<T>(label: string, fn: () => T): T;
+    private commitTemplate;
+    private pushHistory;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undoLabel(): string | undefined;
+    redoLabel(): string | undefined;
+    undo(): boolean;
+    redo(): boolean;
+    /** Replaces the document and clears history (loading a template). */
+    load(template: ReportTemplate): void;
+    history(): {
+        undo: readonly HistoryEntry[];
+        redo: readonly HistoryEntry[];
+    };
+}
+
+interface RenderTreeOptions {
+    registry: BlockRegistry;
+    theme: Theme;
+    styles: DocumentStyles;
+    mode: RenderMode;
+    page: PageContext;
+    format: FormatContext;
+    /** Content width in px at the root. */
+    width: number;
+    /** Hook for editors to add attributes to node wrappers. */
+    decorate?: (node: ResolvedNode, props: VProps) => VProps;
+}
+/** Design-mode chip for a data token. */
+declare function tokenChip(expr: string, label: string | undefined, value?: string): VNode;
+declare function renderSegments(segments: ResolvedSegment[] | undefined, fallback: string | undefined, opts: RenderTreeOptions): VChild[];
+declare function renderInline(content: InlineNode[], opts: RenderTreeOptions): VChild[];
+declare function renderRichText(doc: RichTextDoc | undefined, opts: RenderTreeOptions): VChild[];
+declare function nodeAttrs(node: ResolvedNode, extra?: VProps): VProps;
+/** Width available to a column inside a row. */
+declare function columnWidth(rowWidth: number, span: number, gap: number, columns: number): number;
+/**
+ * Renders a resolved node (and its subtree) to a VNode. This is the single
+ * rendering path used by the editor canvas, the preview and the PDF service.
+ */
+declare function renderNode(node: ResolvedNode, opts: RenderTreeOptions, width?: number): VNode | null;
+/** Renders a list of resolved sections into a fragment-less flat list. */
+declare function renderSections(sections: ResolvedNode[], opts: RenderTreeOptions): VNode[];
+
+export { type AnyVersionTemplate, type BinaryOp, type BindingInfo, type BindingKind, type BindingSpec, type BlockCategory, type BlockDefinition, type BlockNode, BlockRegistry, type BlockRegistryLike, type BlockStyle, type BorderSpec, type BorderStyle, type BreakMode, type BreakRun, CONDITION_OPERATORS, CURRENT_SCHEMA_VERSION, type CardStyle, type ColorValue, type Command, CommandError, type Condition, type ConditionGroup, type ConditionRule, type ContainerSpec, type CreateNodeOptions, type CreateTemplateOptions, type CustomPageSize, DEFAULT_PAGE_CONTEXT, DEFAULT_THEME, type DataSource, type DispatchOptions, type DocumentStyles, type EditorState, EditorStore, type EditorStoreOptions, type EvalContext, type Expr, ExpressionError, FUNCTION_NAMES, type FieldSchema, type FieldType, type FlowOptions, type FontValue, type FormatContext, GLOBAL_SCHEMAS, type GeometryMap, type HistoryEntry, type InlineNode, type InspectorApi, type InspectorComponent, type InspectorField, type InspectorFieldBase, type InspectorSection, type Issue, type IssueCode, type IssueSeverity, type IssueSource, type LayoutWarning, type LibraryItem, type LicenseTier, type List, type ListItem, MIGRATIONS, type Measurer, type Migration, MigrationError, type MigrationResult, type Node, type NodeEntry, type NodeGeometry, type NodeIndex, type NodeLocation, type OutputCheckOptions, PAGE_SIZES_MM, PIPES, PX_PER_MM, type Page, type PageContext, type PageFragment, type PageGeometry, type PageMargins, type PageOrientation, type PageRegionSettings, type PageSettings, type PageSize, type PageSizeName, type PagedDocument, type PaginateOptions, type Paragraph, type ParseResult, type PathSegment, type PipeDefinition, type PipeFn, REGION_IDS, ROW_LAYOUTS, type RegionContent, type RegionId, type RegistryOptions, type RenderContext, type RenderMode, type RenderTreeOptions, type RepeatedHeader, type ReportData, type ReportTemplate, type ResolveHookContext, type ResolveOptions, type ResolvedDocument, type ResolvedFlow, type ResolvedNode, type ResolvedRegion, type ResolvedRole, type ResolvedSegment, type ResolvedStyle, type RichTextDoc, SchemaScope, type SchemaVersion, Scope, type SectionGeometry, type SelectOption, type Spacing, type SplitMode, type StyleCascadeInput, type StyleGroup, type TableRowGeometry, type TableStyle, type TemplateMeta, type TemplateSegment, type TemplateSettings, type TextAlign, type TextMarks, type TextRun, type TextStyle, type TextStyleId, type Theme, type ThemeColors, type ThemeFontFace, type ThemeTableDefaults, type ThemeTokenInfo, type ThemeTypography, type TokenRef, type TokenRun, type TypeIssue, type TypeResult, type VChild, type VNode, type VProps, type ValidateContext, type ValidateOptions, type ValidationResult, type ValueType, type VerticalAlign, ancestors, applyCommand, bestBreak, bindingSpecsFor, blockStyleSchema, checkExpressionSyntax, checkOutput, classNames, cloneWithNewIds, collectPaths, columnWidth, compareValues, compileCondition, computePageGeometry, countNodes, createColumn, createId, createNode, createParagraph, createRichText, createRow, createSchemaScope, createSection, createTemplate, cssText, dataSourceSchemas, defaultDocumentStyles, defaultPageSettings, defineBlock, describeExpression, documentStylesSchema, escapeHtml, evaluate, evaluateAst, evaluateCondition, evaluateText, evaluateToText, exprToString, extractTemplateTokens, findNode, formatCurrency, formatDate, formatDatePattern, formatNumber, formatPercent, getField, getRegion, h, humaniseLabel, humanize, humanizeKey, indexTemplate, inlineFromTemplate, inlineToPlain, interpolate, isDarkColor, isDescendant, isEmptyValue, isRichTextDoc, isSafeUrl, isTokenRef, isVNode, issue, itemSchemaOf, labelForPath, listAt, listThemeTokens, looseEquals, mergeTheme, migrateTemplate, missingThemeValues, mmToPx, needsMigration, nodeAt, nodeAttrs, nodeSchema, pageSettingsSchema, pageSizeMm, paginate, parseExpression, parseTemplate, pathToString, pxToMm, readProperty, readRegion, renderInline, renderNode, renderRichText, renderSections, renderSegments, resolveDefaultProps, resolvePath, resolvePathSchema, resolveStyle, resolveTemplate, resolveToken, resolveValue, richTextFromTemplate, richTextToPlain, richTextTokens, setDeterministicIds, splitTemplate, styleString, styleToCss, synthesizeSampleData, synthesizeValue, templateSchema, textStyleLabel, toDate, toDisplayString, toHtml, toNumber, tokenChip, tokenize, truthy, typeCheck, typeCheckAst, usedBlockTypes, validateTemplate, walkTemplate, walkVNodes };