postext 0.3.16 → 0.3.18

package/dist/types.d.ts

@@ -1,3 +1,7 @@
+/** @deprecated Legacy content-model resource used by the VDT renderer
+ *  (`VDTBlock.resource`). The Resources-panel feature uses the newer
+ *  `Resource` / `ResourceType` model below. Retained until the renderer
+ *  migrates off it. */
 export interface PostextResource {
     id: string;
     type: 'image' | 'table' | 'figure' | 'pullQuote';
@@ -8,6 +12,132 @@ export interface PostextResource {
     width?: number;
     height?: number;
 }
+/** How a counter renders for a given resource type. */
+export type ResourceCounterFormat = 'decimal' | 'roman-lower' | 'roman-upper' | 'alpha-lower' | 'alpha-upper';
+/** When the per-type counter resets back to its starting value. `'never'`
+ *  yields a single document-wide running count; `'h1'..'h6'` resets the
+ *  counter whenever a heading of that level is encountered. */
+export type ResourceCounterReset = 'never' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+/** Where a resource floats on the page. `'top'` / `'bottom'` detach the
+ *  resource from the running text and reserve a band at the top or bottom of
+ *  the next available page near its first reference (the standard editorial
+ *  figure-float behaviour). `'here'` opts out of floating and embeds the
+ *  resource inline at the exact `::resource` directive position. */
+export type ResourceFloatPosition = 'top' | 'bottom' | 'here';
+/** How wide a floated resource is. `'column'` keeps it within a single column;
+ *  `'page'` spans the full content width across all columns (a full-width
+ *  float that breaks the column flow). In a single-column layout the two are
+ *  equivalent. */
+export type ResourceFloatSpan = 'column' | 'page';
+/** Placement of a resource on the page. Resolved per resource, falling back to
+ *  its {@link ResourceType.defaultPlacement} and then the built-in default
+ *  (`top` / `column`). See {@link resolveResourcePlacement}. */
+export interface ResourcePlacement {
+    position?: ResourceFloatPosition;
+    span?: ResourceFloatSpan;
+}
+/** A user-definable category of resource (e.g. "Figure", "Table"). Drives
+ *  numbering, caption prefixes, and inline-reference labels. */
+export interface ResourceType {
+    /** Stable identifier, referenced by `Resource.typeId`. */
+    id: string;
+    /** Display name, singular (e.g. "Figure"). */
+    name: string;
+    /** Optional plural display name (e.g. "Figures"). */
+    namePlural?: string;
+    /** Compact label used in inline references (e.g. "Fig."). */
+    shortLabel: string;
+    /** Template for the computed number. Placeholders: `{n}` (the counter),
+     *  `{h1}`..`{h6}` (current heading numbers). E.g. `'{h1}.{n}'`. */
+    numberingTemplate: string;
+    /** When the counter resets. */
+    resetOn: ResourceCounterReset;
+    /** How the `{n}` counter is formatted. */
+    counterFormat: ResourceCounterFormat;
+    /** Prefix prepended to the caption (e.g. "Figure"). The computed number
+     *  follows this prefix. */
+    captionPrefix: string;
+    /** Default placement for resources of this type, used when a resource does
+     *  not specify its own `placement`. Falls back to `top` / `column`. */
+    defaultPlacement?: ResourcePlacement;
+}
+/** The concrete payload kind a `Resource` carries. */
+export type ResourceKind = 'bitmap' | 'svg' | 'table';
+/** Horizontal alignment of a table cell's content. */
+export type TableCellAlign = 'left' | 'center' | 'right';
+/** Vertical alignment of a table cell's content. */
+export type TableCellVerticalAlign = 'top' | 'middle' | 'bottom';
+/** Position of a cell within a {@link TableModel} grid (zero-based). */
+export interface TableCellPos {
+    row: number;
+    col: number;
+}
+export interface TableCell {
+    /** Cell content (plain text / inline markdown). */
+    content: string;
+    /** Number of columns this cell spans. Default 1. */
+    colSpan?: number;
+    /** Number of rows this cell spans. Default 1. */
+    rowSpan?: number;
+    /** When true, render as a header cell (`<th>`). */
+    isHeader?: boolean;
+    align?: TableCellAlign;
+    verticalAlign?: TableCellVerticalAlign;
+    /** When set, this cell is covered by a merge whose primary (top-left) cell
+     *  is at the referenced position. Hidden cells are skipped during rendering
+     *  and restored on unmerge. */
+    hiddenBy?: TableCellPos;
+}
+export interface TableModel {
+    /** Row-major grid of cells. */
+    rows: TableCell[][];
+    /** Number of leading rows that form the table header. Default 0. */
+    headerRowCount?: number;
+}
+/** A user-managed resource instance. Binary payloads (bitmaps, SVGs) are
+ *  stored out-of-band (IndexedDB in the sandbox) and referenced by
+ *  `fileId`; table resources carry their model inline. */
+export interface Resource {
+    /** Stable identifier, referenced by inline `ref`s. */
+    id: string;
+    /** The `ResourceType.id` this resource belongs to. */
+    typeId: string;
+    kind: ResourceKind;
+    /** Optional caption text (the type prefix + number are computed). */
+    caption?: string;
+    /** Accessibility alt text. */
+    altText?: string;
+    /** Creation timestamp (ms since epoch). */
+    createdAt: number;
+    /** Last-modified timestamp (ms since epoch). */
+    updatedAt: number;
+    /** Present when `kind === 'bitmap'`. */
+    bitmap?: {
+        fileId: string;
+        format: string;
+        width: number;
+        height: number;
+    };
+    /** Present when `kind === 'svg'`. */
+    svg?: {
+        fileId: string;
+        /** Intrinsic width in px (from the SVG's `width`/`height` or `viewBox`),
+         *  used to preserve aspect ratio on layout. Absent for SVGs with no
+         *  declared size. */
+        width?: number;
+        /** Intrinsic height in px; see `width`. */
+        height?: number;
+    };
+    /** Present when `kind === 'table'`. */
+    table?: {
+        model: TableModel;
+    };
+    /** Optional per-resource placement override. When unset, the resource's
+     *  type default (then `top` / `column`) applies. A `position` of `'top'` or
+     *  `'bottom'` floats the resource to a band on the page near its first
+     *  reference; `'here'` embeds it inline at its `::resource` directive. */
+    placement?: ResourcePlacement;
+}
 export interface PostextNote {
     id: string;
     type: 'footnote' | 'endnote' | 'marginNote';
@@ -24,7 +154,11 @@ export interface DocumentMetadata {
 export interface PostextContent {
     markdown: string;
     metadata?: DocumentMetadata;
-    resources?: PostextResource[];
+    /** User-managed resources (issue #49) embedded via `::resource{id=…}` and
+     *  referenced inline via `:ref{id=…}`. Binary payloads (bitmaps, SVGs) are
+     *  resolved out-of-band by the renderer; table resources carry their model
+     *  inline. */
+    resources?: Resource[];
     notes?: PostextNote[];
 }
 export type PlacementStrategy = 'topOfColumn' | 'inline' | 'floatLeft' | 'floatRight' | 'fullWidthBreak' | 'margin';
@@ -192,12 +326,24 @@ export interface BodyTextConfig {
     color?: ColorValue;
     boldColor?: ColorValue;
     italicColor?: ColorValue;
+    /** Colour of inline `:ref` reference labels (e.g. "Fig. 1.7"). Defaults to
+     *  {@link boldColor} (the emphasis colour). */
+    referenceColor?: ColorValue;
+    /** Whether reference labels are rendered in the bold font. Default `true`. */
+    referenceBold?: boolean;
+    /** Whether reference labels are rendered italic. Default `false`. */
+    referenceItalic?: boolean;
     textAlign?: TextAlign;
     fontWeight?: number;
     boldFontWeight?: number;
     hyphenation?: HyphenationConfig;
     firstLineIndent?: Dimension;
     hangingIndent?: boolean;
+    /** When `false`, the first paragraph immediately following a heading is
+     *  rendered without first-line indent. A common typographic convention in
+     *  scientific publications and many book styles ("indent run-in" style).
+     *  Default `true` — every paragraph receives the indent. */
+    indentAfterHeading?: boolean;
     /** Max word-spacing when justifying, as a multiplier of the normal space width.
      *  Lines that would exceed this trigger extra hyphenation/reflow attempts. */
     maxWordSpacing?: number;
@@ -267,12 +413,19 @@ export interface ResolvedBodyTextConfig {
     color: ColorValue;
     boldColor?: ColorValue;
     italicColor?: ColorValue;
+    /** Resolved colour for inline `:ref` labels (defaults to the bold colour). */
+    referenceColor: ColorValue;
+    /** Whether reference labels use the bold font. */
+    referenceBold: boolean;
+    /** Whether reference labels are italic. */
+    referenceItalic: boolean;
     textAlign: TextAlign;
     fontWeight: number;
     boldFontWeight: number;
     hyphenation: ResolvedHyphenationConfig;
     firstLineIndent: Dimension;
     hangingIndent: boolean;
+    indentAfterHeading: boolean;
     maxWordSpacing: number;
     minWordSpacing: number;
     optimalLineBreaking: boolean;
@@ -291,6 +444,113 @@ export interface ResolvedBodyTextConfig {
     avoidRuntsInLists: boolean;
     keepColonWithList: boolean;
 }
+/** User-facing styling for embedded `kind: 'table'` resources. Every field is
+ *  optional; unset fields inherit body-text defaults (font family, size,
+ *  colour) so a document with no table config looks the same as before this
+ *  config existed. See {@link ResolvedTableStyleConfig}. */
+export interface TableStyleConfig {
+    /** Body-cell font family. Defaults to the body-text family. */
+    bodyFontFamily?: string;
+    /** Body-cell font size. Defaults to the body-text size. */
+    bodyFontSize?: Dimension;
+    /** Body-cell text colour. Defaults to the body-text colour. */
+    bodyColor?: ColorValue;
+    /** Header-cell font family. Defaults to the body-text family. */
+    headerFontFamily?: string;
+    /** Header-cell font size. Defaults to the body-text size. */
+    headerFontSize?: Dimension;
+    /** Header-cell text colour. Defaults to the body-text colour. */
+    headerColor?: ColorValue;
+    /** Render header cells bold. Default `true`. */
+    headerBold?: boolean;
+    /** Render header cells italic. Default `false`. */
+    headerItalic?: boolean;
+    /** Fill header cells with {@link headerBackground}. Default `true`. */
+    headerBackgroundEnabled?: boolean;
+    /** Header-cell fill colour. Default light grey. */
+    headerBackground?: ColorValue;
+    /** Fill body cells with {@link bodyBackground}. Default `false`. */
+    bodyBackgroundEnabled?: boolean;
+    /** Body-cell fill colour. Default white. */
+    bodyBackground?: ColorValue;
+    /** Draw cell borders. Default `true`. */
+    borders?: boolean;
+    /** Border colour. Defaults to the body-text colour. */
+    borderColor?: ColorValue;
+    /** Border thickness. Default `0.75pt` (≈1px at 96dpi). */
+    borderWidth?: Dimension;
+    /** Inner padding inside each cell. Default `0.375em`. */
+    cellPadding?: Dimension;
+}
+export interface ResolvedTableStyleConfig {
+    bodyFontFamily: string;
+    bodyFontSize: Dimension;
+    bodyColor: ColorValue;
+    headerFontFamily: string;
+    headerFontSize: Dimension;
+    headerColor: ColorValue;
+    headerBold: boolean;
+    headerItalic: boolean;
+    headerBackgroundEnabled: boolean;
+    headerBackground: ColorValue;
+    bodyBackgroundEnabled: boolean;
+    bodyBackground: ColorValue;
+    borders: boolean;
+    borderColor: ColorValue;
+    borderWidth: Dimension;
+    cellPadding: Dimension;
+}
+/** User-facing styling for resource captions (the numbered label such as
+ *  "Figure 1." plus the description text). The label and description share one
+ *  typeface and size (the caption is measured as a single wrapped run); they
+ *  differ in weight, slant, and colour. Every field is optional and inherits
+ *  body-text defaults. See {@link ResolvedCaptionStyleConfig}. */
+export interface CaptionStyleConfig {
+    /** Caption font family (label + description). Defaults to the body family. */
+    fontFamily?: string;
+    /** Caption font size (label + description). Defaults to the body size. */
+    fontSize?: Dimension;
+    /** Description text colour. Defaults to the body-text colour. */
+    color?: ColorValue;
+    /** Horizontal alignment of caption text. Default `'left'`. */
+    align?: TextAlign;
+    /** Gap between the figure body and the caption. Default `0.75em`. */
+    gap?: Dimension;
+    /** Render the numbered label bold. Default `true`. */
+    labelBold?: boolean;
+    /** Render the numbered label italic. Default `false`. */
+    labelItalic?: boolean;
+    /** Numbered-label colour. Defaults to {@link color}. */
+    labelColor?: ColorValue;
+    /** Render the description italic. Default `false`. */
+    descriptionItalic?: boolean;
+}
+export interface ResolvedCaptionStyleConfig {
+    fontFamily: string;
+    fontSize: Dimension;
+    color: ColorValue;
+    align: TextAlign;
+    gap: Dimension;
+    labelBold: boolean;
+    labelItalic: boolean;
+    labelColor: ColorValue;
+    descriptionItalic: boolean;
+}
+/** Styling for embedded SVG diagrams (`kind: 'svg'` resources). When
+ *  {@link singleInk} is on, every colour in the SVG is remapped to a tint of
+ *  {@link inkColor} by luminance — light fills become light tints, dark
+ *  strokes and text approach the full ink — so figures reproduce faithfully
+ *  when a document is printed with a single spot colour. */
+export interface DiagramStyleConfig {
+    /** Recolour diagrams to tints of a single ink. Default `false`. */
+    singleInk?: boolean;
+    /** The ink. Defaults to the document's main palette colour. */
+    inkColor?: ColorValue;
+}
+export interface ResolvedDiagramStyleConfig {
+    singleInk: boolean;
+    inkColor: ColorValue;
+}
 /** Parity constraint for a forced page break.
  *
  *  - `'any'` — no constraint; the break just opens a new page.
@@ -315,6 +575,23 @@ export interface ResolvedHeadingBreakBeforeConfig {
     enabled: boolean;
     parity: HeadingBreakParity;
 }
+/** Whether a heading occupies the single column it sits in, or spans the
+ *  full page content width. `'page'` only takes effect on headings that
+ *  start a new page (via `breakBefore.enabled`). */
+export type HeadingSpan = 'column' | 'page';
+/** Advanced design configuration for a heading level. When `enabled: true`
+ *  the heading is rendered from `slot` and the inline typography fields
+ *  (`fontFamily`, `fontSize`, `fontWeight`, `color`, `italic`,
+ *  `numberingTemplate`-as-prefix) on `HeadingLevelConfig` are ignored. The
+ *  heading's own text is carried via the `{titleText}` placeholder. */
+export interface HeadingAdvancedDesignConfig {
+    enabled: boolean;
+    slot: DesignSlot;
+}
+export interface ResolvedHeadingAdvancedDesignConfig {
+    enabled: boolean;
+    slot: ResolvedDesignSlot;
+}
 export interface HeadingLevelConfig {
     level: number;
     fontSize?: Dimension;
@@ -327,6 +604,10 @@ export interface HeadingLevelConfig {
     numberingTemplate?: string;
     italic?: boolean;
     breakBefore?: HeadingBreakBeforeConfig;
+    /** Column vs full-page span. Default `'column'`. */
+    span?: HeadingSpan;
+    /** When enabled, the heading renders as a design slot. */
+    advancedDesign?: HeadingAdvancedDesignConfig;
 }
 export interface ResolvedHeadingLevelConfig {
     level: number;
@@ -340,6 +621,8 @@ export interface ResolvedHeadingLevelConfig {
     numberingTemplate: string;
     italic: boolean;
     breakBefore: ResolvedHeadingBreakBeforeConfig;
+    span: HeadingSpan;
+    advancedDesign: ResolvedHeadingAdvancedDesignConfig;
 }
 export interface HeadingsConfig {
     fontFamily?: string;
@@ -354,8 +637,19 @@ export interface HeadingsConfig {
      *  heading, the heading is pushed to the next column/page so it stays joined
      *  to its text. Default true. */
     keepWithNext?: boolean;
+    /** Vertical column balancing — editorial bottom alignment. When a column
+     *  ends short of its bottom, extra baseline-grid lines are added above the
+     *  column's headings so every column ends flush with the page bottom.
+     *  Extra lines are distributed across the column's headings, favouring the
+     *  most important (lowest-level) heading. Default enabled. */
+    balancing?: ColumnBalancingConfig;
     levels?: HeadingLevelConfig[];
 }
+export interface ColumnBalancingConfig {
+    enabled?: boolean;
+    /** Maximum extra grid lines that may be added above a single heading. */
+    maxLinesPerHeading?: number;
+}
 export interface ResolvedHeadingsConfig {
     fontFamily: string;
     lineHeight: Dimension;
@@ -365,6 +659,10 @@ export interface ResolvedHeadingsConfig {
     marginTop: Dimension;
     marginBottom: Dimension;
     keepWithNext: boolean;
+    balancing: {
+        enabled: boolean;
+        maxLinesPerHeading: number;
+    };
     levels: ResolvedHeadingLevelConfig[];
 }
 export interface UnorderedListLevelConfig {
@@ -514,6 +812,7 @@ export interface WarningsToggleConfig {
     headingHierarchy?: boolean;
     consecutiveHeadings?: boolean;
     listAfterHeading?: boolean;
+    designIssues?: boolean;
 }
 export interface ResolvedWarningsToggleConfig {
     missingFont: boolean;
@@ -521,6 +820,7 @@ export interface ResolvedWarningsToggleConfig {
     headingHierarchy: boolean;
     consecutiveHeadings: boolean;
     listAfterHeading: boolean;
+    designIssues: boolean;
 }
 export interface DebugConfig {
     cursorSync?: SyncIndicatorConfig;
@@ -631,13 +931,115 @@ export interface CustomFontFamily {
 }
 export type PageParity = 'all' | 'odd' | 'even';
 export type HeaderFooterHAlign = 'left' | 'center' | 'right';
-export interface HeaderFooterTextElement {
+export type HAlign = 'left' | 'center' | 'right';
+export type VAlign = 'top' | 'middle' | 'bottom';
+export type AnchorEdge = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right' | 'right-of' | 'left-of' | 'below' | 'above' | 'align-top' | 'align-bottom' | 'align-left' | 'align-right';
+export interface ElementAnchor {
+    /** `'container'` or `'#elementId'` reference to another element in the slot. */
+    to: 'container' | `#${string}`;
+    edge: AnchorEdge;
+}
+export type ElementSize = 'auto' | 'fill' | Dimension;
+export interface ElementPlacement {
+    anchor: ElementAnchor;
+    offset?: {
+        x?: Dimension;
+        y?: Dimension;
+    };
+    size?: {
+        width?: ElementSize;
+        height?: ElementSize;
+    };
+}
+export interface ElementBoxStyle {
+    backgroundColor?: ColorValue;
+    borderColor?: ColorValue;
+    borderWidth?: Dimension;
+    borderRadius?: Dimension;
+    padding?: {
+        top?: Dimension;
+        right?: Dimension;
+        bottom?: Dimension;
+        left?: Dimension;
+    };
+}
+export type TextOverflow = 'wrap' | 'ellipsis-start' | 'ellipsis-end' | 'ellipsis-middle' | 'clip';
+export interface DesignTextElement {
     kind: 'text';
-    align: HeaderFooterHAlign;
-    /** Template string. Placeholders: {pageNumber}, {totalPages}, {title},
-     *  {subtitle}, {author}, {publishDate}, {chapterTitle}. Use `{{` / `}}`
+    /** Stable, unique within the slot. Anchors reference elements by `#id`. */
+    id: string;
+    /** Header/footer only; ignored by heading designs. */
+    parity?: PageParity;
+    placement: ElementPlacement;
+    /** Template with placeholders (see design/placeholders.ts). Use `{{`/`}}`
      *  for literal braces. */
     content: string;
+    fontFamily?: string;
+    fontSize: Dimension;
+    fontWeight?: number;
+    italic?: boolean;
+    color?: ColorValue;
+    /** Horizontal alignment within the element's box. */
+    align?: HAlign;
+    /** Vertical alignment within the element's box. */
+    verticalAlign?: VAlign;
+    lineHeight?: number;
+    letterSpacing?: Dimension;
+    overflow: TextOverflow;
+    /** When true, break long words at syllable boundaries while wrapping.
+     *  Uses the document's active hyphenation locale. */
+    hyphenate?: boolean;
+    box?: ElementBoxStyle;
+}
+export interface DesignRuleElement {
+    kind: 'rule';
+    id: string;
+    parity?: PageParity;
+    placement: ElementPlacement;
+    direction: 'horizontal' | 'vertical';
+    color: ColorValue;
+    thickness: Dimension;
+}
+export interface DesignBoxElement {
+    kind: 'box';
+    id: string;
+    parity?: PageParity;
+    placement: ElementPlacement;
+    style: ElementBoxStyle;
+}
+export type DesignElement = DesignTextElement | DesignRuleElement | DesignBoxElement;
+export interface DesignSlot {
+    /** Array order = paint order: first = back, last = front. */
+    elements: DesignElement[];
+}
+export interface ResolvedDesignTextElement extends Omit<DesignTextElement, 'fontFamily' | 'fontWeight' | 'italic' | 'color' | 'align' | 'verticalAlign' | 'lineHeight' | 'parity'> {
+    parity: PageParity;
+    fontFamily: string;
+    fontWeight: number;
+    italic: boolean;
+    color: ColorValue;
+    align: HAlign;
+    verticalAlign: VAlign;
+    lineHeight: number;
+}
+export interface ResolvedDesignRuleElement extends Omit<DesignRuleElement, 'parity'> {
+    parity: PageParity;
+}
+export interface ResolvedDesignBoxElement extends Omit<DesignBoxElement, 'parity'> {
+    parity: PageParity;
+}
+export type ResolvedDesignElement = ResolvedDesignTextElement | ResolvedDesignRuleElement | ResolvedDesignBoxElement;
+export interface ResolvedDesignSlot {
+    elements: ResolvedDesignElement[];
+}
+export type HeaderFooterElement = DesignElement;
+export type HeaderFooterSlot = DesignSlot;
+export type ResolvedHeaderFooterElement = ResolvedDesignElement;
+export type ResolvedHeaderFooterSlot = ResolvedDesignSlot;
+export interface LegacyHeaderFooterTextElement {
+    kind: 'text';
+    align: HeaderFooterHAlign;
+    content: string;
     parity: PageParity;
     /** Absolute distance between the element's body-facing edge and the body
      *  edge. Elements are independent — two with the same `marginFromBody`
@@ -654,57 +1056,39 @@ export interface HeaderFooterTextElement {
     italic?: boolean;
     color?: ColorValue;
 }
-export interface HeaderFooterRuleElement {
+export interface LegacyHeaderFooterRuleElement {
     kind: 'rule';
     color: ColorValue;
     thickness: Dimension;
-    /** Rule width — a Dimension or the literal 'full' meaning full content width. */
     width: Dimension | 'full';
     align: HeaderFooterHAlign;
-    /** Absolute distance from the rule's body-facing edge to the body edge.
-     *  Independent of other elements. */
     marginFromBody?: Dimension;
-    /** Horizontal inset from the aligned content edge. Only applies when
-     *  `width` is a `Dimension` and `align` is `'left'` or `'right'`. */
     marginFromEdge?: Dimension;
     parity: PageParity;
 }
-export type HeaderFooterElement = HeaderFooterTextElement | HeaderFooterRuleElement;
-export interface HeaderFooterSlot {
-    elements: HeaderFooterElement[];
-}
-export interface ResolvedHeaderFooterTextElement {
-    kind: 'text';
-    align: HeaderFooterHAlign;
-    content: string;
-    parity: PageParity;
-    marginFromBody: Dimension;
-    marginFromEdge: Dimension;
-    fontFamily: string;
-    fontSize: Dimension;
-    fontWeight: number;
-    italic: boolean;
-    color: ColorValue;
-}
-export interface ResolvedHeaderFooterRuleElement {
-    kind: 'rule';
-    color: ColorValue;
-    thickness: Dimension;
-    width: Dimension | 'full';
-    align: HeaderFooterHAlign;
-    marginFromBody: Dimension;
-    marginFromEdge: Dimension;
-    parity: PageParity;
-}
-export type ResolvedHeaderFooterElement = ResolvedHeaderFooterTextElement | ResolvedHeaderFooterRuleElement;
-export interface ResolvedHeaderFooterSlot {
-    elements: ResolvedHeaderFooterElement[];
+export type LegacyHeaderFooterElement = LegacyHeaderFooterTextElement | LegacyHeaderFooterRuleElement;
+export interface LegacyHeaderFooterSlot {
+    elements: LegacyHeaderFooterElement[];
 }
+/** @deprecated Use `DesignTextElement`. Kept as alias for legacy API exports. */
+export type HeaderFooterTextElement = DesignTextElement;
+/** @deprecated Use `DesignRuleElement`. */
+export type HeaderFooterRuleElement = DesignRuleElement;
+/** @deprecated Use `ResolvedDesignTextElement`. */
+export type ResolvedHeaderFooterTextElement = ResolvedDesignTextElement;
+/** @deprecated Use `ResolvedDesignRuleElement`. */
+export type ResolvedHeaderFooterRuleElement = ResolvedDesignRuleElement;
 export interface PostextConfig {
     page?: PageConfig;
     layout?: LayoutConfig;
     bodyText?: BodyTextConfig;
     headings?: HeadingsConfig;
+    /** Styling for embedded table resources. */
+    tableStyle?: TableStyleConfig;
+    /** Styling for resource captions (numbered label + description). */
+    captionStyle?: CaptionStyleConfig;
+    /** Styling for embedded SVG diagrams (single-ink reproduction). */
+    diagramStyle?: DiagramStyleConfig;
     unorderedLists?: UnorderedListsConfig;
     orderedLists?: OrderedListsConfig;
     math?: MathConfig;
@@ -731,5 +1115,9 @@ export interface PostextConfig {
      *  Google Font. Binary data is stored out-of-band (IndexedDB in the
      *  sandbox) and referenced by `fileId`. */
     customFonts?: CustomFontFamily[];
+    /** User-definable resource categories (figures, tables, etc.) that drive
+     *  typed numbering, caption prefixes, and inline references. Defaults to
+     *  the built-in 'figure' and 'table' types when unset. */
+    resourceTypes?: ResourceType[];
 }
 //# sourceMappingURL=types.d.ts.map