wordinweb 0.3.7 → 0.3.8

package/dist/docx-only-D3pk2pRD.d.ts

@@ -0,0 +1,2944 @@
+interface XmlElement {
+    name: string;
+    attrs: Record<string, string>;
+    children: XmlElement[];
+    /** Concatenated character data directly inside this element. */
+    text: string;
+    /** Editor placeholder retained in memory but omitted from XML while empty. */
+    omitWhenEmpty?: boolean;
+}
+
+/**
+ * Typed document model produced by the parser and consumed by the layout
+ * engine. All lengths are CSS px (see units.ts) unless a field name says
+ * otherwise. Property bags are Partial-style: `undefined` means "not set at
+ * this level" so the style-inheritance merge can distinguish absence from an
+ * explicit value.
+ *
+ * Model nodes keep `src` references to the XML elements they were parsed
+ * from: the XML tree is the source of truth for editing — commands mutate it
+ * and the model is re-derived, which preserves round-trip fidelity for
+ * everything untouched.
+ */
+
+type BorderStyle = "none" | "single" | "double" | "dotted" | "dashed" | "thick" | "wave" | "dotDash" | "dotDotDash" | "thinThickSmallGap" | "triple";
+interface Border {
+    style: BorderStyle;
+    /** Stroke width in px. */
+    width: number;
+    /** CSS color. */
+    color: string;
+    /** Gap between border and content in px (w:space, points in OOXML). */
+    space: number;
+    /** Declared stroke width in px BEFORE the 0.75px paint floor (w:sz/8 pt).
+     * Word's LAYOUT math (table row border share) uses this true width — a
+     * sz-4 rule contributes 0.5pt, not the floored 0.5625pt (phase23 p66:
+     * 45 rows drift 2.5px down without it). */
+    rawWidth?: number;
+    /** w:shadow: a strip outside the right and bottom borders. */
+    shadow?: boolean;
+}
+interface ParagraphBorders {
+    top?: Border;
+    bottom?: Border;
+    left?: Border;
+    right?: Border;
+    /** Drawn between consecutive paragraphs that both specify it. */
+    between?: Border;
+}
+type LineSpacingRule = "auto" | "atLeast" | "exact";
+interface LineSpacing {
+    rule: LineSpacingRule;
+    /**
+     * For "auto": multiple of single line height (240ths in OOXML, stored here
+     * as the multiplier, e.g. 1.15). For atLeast/exact: px.
+     */
+    value: number;
+}
+type Alignment = "left" | "center" | "right" | "justify";
+interface TabStop {
+    /** px from the left text edge */
+    pos: number;
+    align: "left" | "center" | "right" | "decimal" | "bar";
+    leader: "none" | "dot" | "hyphen" | "underscore" | "middleDot";
+    /** w:val="clear": removes the inherited stop at this pos when tab lists
+     * merge down the style chain (never a live stop itself). */
+    clear?: boolean;
+}
+interface RunProps {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: string;
+    strike?: boolean;
+    doubleStrike?: boolean;
+    /** Resolved primary font family name (ascii/hAnsi, theme-resolved). */
+    font?: string;
+    /** East Asian font (rFonts w:eastAsia): used for CJK codepoints. */
+    fontEastAsia?: string;
+    /** hAnsi font (rFonts w:hAnsi, theme-resolved): Word uses this channel for
+     * non-ASCII, non-CJK, non-complex characters (curly quotes, ≤, dashes). A
+     * run that declares only w:ascii leaves it inherited from the style chain. */
+    fontHAnsi?: string;
+    /** Complex-script font (rFonts w:cs): used for RTL/complex runs. */
+    fontComplex?: string;
+    /** w:rtl — this run's text is right-to-left (Arabic/Hebrew). */
+    rtl?: boolean;
+    /** Font size in px. */
+    size?: number;
+    /** CSS color; "auto" resolved to inherit/black by renderer. */
+    color?: string;
+    highlight?: string;
+    /** Character shading fill (w:shd). */
+    shading?: string;
+    /** Run border (w:bdr): a box painted around the run. Word merges adjacent
+     * runs with identical borders into one box; a run wrapping across lines
+     * closes the box on every line segment. */
+    border?: Border;
+    verticalAlign?: "baseline" | "superscript" | "subscript";
+    caps?: boolean;
+    smallCaps?: boolean;
+    /** Letter spacing px (w:spacing, twips in OOXML). */
+    letterSpacing?: number;
+    /** Minimum font size in px at which w:kern enables pair kerning; null is
+     * the explicit w:kern=0 override. */
+    kerningThreshold?: number | null;
+    /** Paint-only letter spacing when layout advances intentionally differ. */
+    paintLetterSpacing?: number;
+    /** w:w horizontal character scaling as a fraction (1.5 = 150%). */
+    textScale?: number;
+    /** w:fitText target width in px: the run's advances scale so its text
+     * occupies exactly this width (resolved to textScale at layout time). */
+    fitText?: number;
+    /** w:position baseline shift in px, positive = raised. */
+    raise?: number;
+    /** w:outline — hollow stroked glyphs. */
+    outline?: boolean;
+    /** w14:textOutline — glyph outline stroke (WordArt gallery styles). */
+    textOutline?: {
+        color: string;
+        width: number;
+    };
+    /** w:shadow / w14:shadow — offset glyph shadow. */
+    textShadow?: boolean;
+    /** w:emboss / w:imprint — Word triple-draws offset copies. */
+    emboss?: boolean;
+    imprint?: boolean;
+    vanish?: boolean;
+    /** w:rPr w:snapToGrid: whether this run participates in the section's
+     * docGrid. A line whose runs ALL declare 0 lays off the grid (see
+     * finishLine); ParaProps.snapToGrid covers the whole paragraph. */
+    snapToGrid?: boolean;
+    /** Character style id (w:rStyle). */
+    styleId?: string;
+    lang?: string;
+    /** w:lang w:bidi — the language of the run's complex-script text (Arabic, Hebrew, Indic, Thai, ...). */
+    langBidi?: string;
+}
+interface NumberingRef {
+    numId: number;
+    ilvl: number;
+}
+interface ParaProps {
+    styleId?: string;
+    alignment?: Alignment;
+    /** The exact OOXML w:jc value when it is a "justify" flavor whose behavior
+     * differs from plain "both": `distribute` also stretches the LAST line, and
+     * the Arabic `*Kashida` levels elongate glyphs (kashida) so lines pack fewer
+     * words and — at medium/high — wrap to more lines. Absent for plain "both".
+     * `alignment` stays "justify" for all of these. */
+    justifyKind?: "distribute" | "lowKashida" | "mediumKashida" | "highKashida";
+    /** w:bidi — right-to-left paragraph: lines assemble RTL and default
+     * alignment flips to the right edge. */
+    bidi?: boolean;
+    /** px */
+    indentLeft?: number;
+    indentRight?: number;
+    /** Positive px; mutually exclusive with hanging in effect. */
+    indentFirstLine?: number;
+    /** Positive px hanging indent. */
+    indentHanging?: number;
+    spacingBefore?: number;
+    spacingAfter?: number;
+    /** w:beforeAutospacing/afterAutospacing: HTML-style automatic paragraph
+     * spacing — Word ignores the literal before/after and inserts one blank
+     * line's worth of space. */
+    beforeAutospacing?: boolean;
+    afterAutospacing?: boolean;
+    /** Word's default when absent is auto/1.0 via docDefaults. */
+    lineSpacing?: LineSpacing;
+    /** w:snapToGrid: whether this paragraph's lines use the section docGrid. */
+    snapToGrid?: boolean;
+    contextualSpacing?: boolean;
+    keepNext?: boolean;
+    /** w:framePr w:dropCap: the paragraph is a drop-cap letter frame. */
+    dropCap?: {
+        mode: "drop" | "margin";
+        lines: number;
+        hSpace: number;
+        pageAnchored?: boolean;
+    };
+    /** w:framePr positioned text frame (absolute-positioned paragraph the body
+     * text wraps around). Geometry in px. Individual attributes are optional so a
+     * framePr merges attribute-by-attribute across the style cascade (a direct
+     * framePr that sets only h/x/y keeps the style framePr's width/anchor — IEEE
+     * authors); the engine normalizes defaults at layout time. */
+    frame?: {
+        w?: number;
+        h?: number;
+        hRule?: "auto" | "atLeast" | "exact";
+        x?: number;
+        y?: number;
+        hAnchor?: "page" | "margin" | "text" | "column";
+        vAnchor?: "page" | "margin" | "text" | "paragraph";
+        xAlign?: "left" | "center" | "right" | "inside" | "outside";
+        yAlign?: "top" | "center" | "bottom" | "inside" | "outside" | "inline";
+        wrap?: "around" | "auto" | "notBeside" | "through" | "tight" | "none";
+        /** w:hSpace / w:vSpace: horizontal/vertical margin around the frame (px). */
+        hSpace?: number;
+        vSpace?: number;
+    };
+    keepLines?: boolean;
+    pageBreakBefore?: boolean;
+    widowControl?: boolean;
+    borders?: ParagraphBorders;
+    /** Paragraph shading fill as CSS color. */
+    shading?: string;
+    numbering?: NumberingRef | null;
+    /** A numPr that carries ilvl but no numId (Heading3 basedOn Heading2)
+     * overrides only the list LEVEL, keeping the inherited numId; the style
+     * chain applies it to `numbering` on merge. */
+    numberingLevelOverride?: number;
+    tabs?: TabStop[];
+    outlineLevel?: number;
+    /** Run props declared on pPr/rPr — apply to the paragraph mark & numbering label. */
+    markRunProps?: RunProps;
+    /**
+     * styleId of the enclosing table (set on cell paragraphs at parse time).
+     * A table style's own pPr layers between docDefaults and the paragraph
+     * style, e.g. TableGrid's `spacing after=0 line=240` overrides docDefaults'
+     * `after=200 line=276` so list cells lay out compactly.
+     */
+    tableStyleId?: string;
+    /**
+     * Grid position of the enclosing cell plus the table's tblLook (set on cell
+     * paragraphs at parse time, like tableStyleId). Lets run/paragraph
+     * resolution layer the applicable w:tblStylePr conditional formats (e.g.
+     * firstRow bold + white) between the table style's own rPr and the
+     * paragraph style chain.
+     */
+    tableCellCond?: {
+        look?: TableLook;
+        rowIdx: number;
+        nRows: number;
+        colStart: number;
+        colSpan: number;
+        nCols: number;
+    };
+}
+interface TextContent {
+    kind: "text";
+    text: string;
+    /** Source w:t element inside the run, when this text came verbatim from one. */
+    srcT?: XmlElement;
+    /** When this text is the glyph of a modern checkbox content control, the
+     * source `w14:checkbox` element (in the enclosing w:sdt's sdtPr). Its
+     * presence makes the glyph a click-to-toggle target rather than plain text. */
+    checkbox?: XmlElement;
+}
+interface BreakContent {
+    kind: "break";
+    breakType: "line" | "page" | "column";
+}
+interface TabContent {
+    kind: "tab";
+}
+interface PTabContent {
+    kind: "ptab";
+    /** Absolute-position tab: jump to left/center/right of the base. */
+    alignment: "left" | "center" | "right";
+    relativeTo: "margin" | "indent";
+}
+interface ImageContent {
+    kind: "image";
+    /** Part path of the image inside the package. */
+    part: string;
+    width: number;
+    height: number;
+    /** True when the drawing is floating (wp:anchor); v1 lays it out inline. */
+    anchored?: boolean;
+    /** a:srcRect crop, fractions of the source bitmap. */
+    crop?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    /** a:xfrm rotation, degrees clockwise. */
+    rotation?: number;
+    /** a:ln picture outline (Word draws it just outside the image). */
+    border?: {
+        color: string;
+        width: number;
+    };
+    /** Source w:drawing (or pict) element, for resize/move editing. */
+    srcDrawing?: XmlElement;
+    /** Native Office 3D model shown through its saved poster raster. */
+    model3D?: Model3DReference;
+    /** Word online-video metadata shown through its saved poster raster. */
+    webVideo?: WebVideoReference;
+    /** Embedded OLE package activated as a safe download in the browser. */
+    embeddedObject?: EmbeddedObjectReference;
+}
+interface Model3DReference {
+    part: string;
+    posterPart: string;
+    /** Native Office model orientation, in degrees around the X/Y/Z axes. */
+    rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+interface WebVideoReference {
+    url: string;
+    embeddedHtml: string;
+    width: number;
+    height: number;
+}
+interface EmbeddedObjectReference {
+    part: string;
+    filename: string;
+    progId: string;
+}
+/** OMML equation node (subset: runs, scripts, fractions, radicals). */
+type MathNode = ({
+    t: "run";
+    text: string;
+    normal?: boolean;
+    /** m:func function name (cos, log, …): Word kerns a thin space on
+     * both sides of the name. */
+    fname?: boolean;
+    /** The run's w:rPr color (hex, no #), strike and underline, when set:
+     * a redline marks an equation's runs with them. */
+    color?: string;
+    strike?: boolean;
+    underline?: string;
+} | {
+    t: "sup" | "sub";
+    base: MathNode[];
+    script: MathNode[];
+} | {
+    t: "frac";
+    num: MathNode[];
+    den: MathNode[];
+    bar?: boolean;
+}
+/** Radical; deg is the optional m:deg index (∛), absent when m:degHide. */
+ | {
+    t: "rad";
+    e: MathNode[];
+    deg?: MathNode[];
+}
+/** n-ary operator (sum/integral); chr defaults to the integral sign. */
+ | {
+    t: "nary";
+    chr: string;
+    sub: MathNode[];
+    sup: MathNode[];
+    e: MathNode[];
+}
+/** Delimiters grown to the content height; beg/end default to parens.
+ * An empty beg/end string means that side has no delimiter (cases "{"). */
+ | {
+    t: "dlm";
+    beg: string;
+    end: string;
+    e: MathNode[][];
+}
+/** Matrix: rows x cells. */
+ | {
+    t: "mat";
+    rows: MathNode[][][];
+}
+/** m:eqArr equation array (cases/piecewise rows). */
+ | {
+    t: "eqarr";
+    rows: MathNode[][];
+}
+/** m:acc combining accent (hat/bar/vector) over the base. */
+ | {
+    t: "acc";
+    chr: string;
+    e: MathNode[];
+}
+/** m:groupChr horizontal group character (over/under brace). */
+ | {
+    t: "grp";
+    chr: string;
+    pos: "top" | "bot";
+    vertJc: "top" | "bot";
+    e: MathNode[];
+}
+/** m:limLow / m:limUpp limit stacked under/over a text operator. */
+ | {
+    t: "lim";
+    pos: "low" | "upp";
+    e: MathNode[];
+    lim: MathNode[];
+}) & {
+    /**
+     * The OMML element this node was read from. Only the math EDITOR's reader
+     * (edit/math.ts) sets it; the renderer's parser leaves it undefined. Editing
+     * re-emits through it, so the properties the linear syntax does not spell
+     * out — run fonts, m:ctrlPr, a matrix's column specs, an n-ary's limit
+     * placement — survive a text edit instead of being dropped.
+     */
+    src?: XmlElement;
+};
+interface MathContent {
+    kind: "math";
+    nodes: MathNode[];
+    /** Source m:oMath element (math editing). */
+    src?: XmlElement;
+    /** Display equation (wrapped in m:oMathPara): centered on its own line with
+     * display-style layout - larger n-ary operators with limits stacked
+     * above/below, and full-size fraction numerators/denominators. */
+    display?: boolean;
+    /** Display group with several direct equations. Word leaves a small
+     * advance after script clusters in these grouped displays. */
+    multiEquationDisplay?: boolean;
+    /** m:oMathParaPr/m:jc - display-equation justification. Absent: the
+     * document default (settings m:mathPr/m:defJc, itself "centerGroup" when
+     * unset). */
+    jc?: "left" | "right" | "center" | "centerGroup";
+}
+interface FieldContent {
+    kind: "field";
+    /** Raw field instruction, e.g. ` PAGE \\* MERGEFORMAT `. */
+    instruction: string;
+    /** Instruction text and nested fields in source order. `instruction` uses
+     * their stored results; layout evaluates these parts to build the code. */
+    instructionParts?: (string | FieldContent)[];
+    /** Last cached result text from the file, used for unsupported fields. */
+    cachedResult: string;
+    /** When this field is a legacy FORMCHECKBOX, the source `w:checkBox` element
+     * (in the fldChar begin's w:ffData). Its presence makes the rendered ballot
+     * box a click-to-toggle target; the glyph derives from its w:checked child. */
+    checkbox?: XmlElement;
+    /** The field's own XML: the `w:fldSimple`, or the `w:fldChar` begin of a
+     * complex field. The update pass (edit/update-fields.ts) writes a recomputed
+     * result back through it — layout resolves fields from this model, so
+     * without the link the computed value has nowhere to land in the file. */
+    src?: XmlElement;
+}
+/** What an anchored shape's coordinates are measured from. "char" (relH=
+ * "character") measures from the anchor run's pen position; "line" (relV=
+ * "line") from the top of the line holding the anchor — both resolved from
+ * the anchor paragraph's first-pass layout. */
+type AnchorRel = "page" | "margin" | "text" | "column" | "char" | "line";
+interface ShapeLine {
+    type: "line";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    color: string;
+    /** Stroke weight px. */
+    weight: number;
+    style?: "single" | "dotted" | "dashed";
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+    /** Source VML v:line for selection and save-back editing. */
+    src?: XmlElement;
+}
+interface ShapeTextbox {
+    type: "textbox";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+    blocks: Block[];
+    /** Background fill (CSS color) painted behind the text. */
+    fill?: string;
+    /** Outline. */
+    stroke?: {
+        color: string;
+        weight: number;
+    };
+    /** Alignment-based positioning (mso-position-horizontal/vertical). */
+    hAlign?: "left" | "center" | "right";
+    vAlign?: "top" | "center" | "bottom";
+    /** Percent-of-base geometry, 0..1 (mso-*-percent / wp14 pct offsets).
+     * Bases: pctWidthRel/pctHeightRel say page vs margin. */
+    pctX?: number;
+    pctY?: number;
+    pctWidth?: number;
+    pctHeight?: number;
+    pctWidthRel?: "page" | "margin";
+    pctHeightRel?: "page" | "margin";
+    /** Vertical anchoring of the text INSIDE the box (v-text-anchor). */
+    textAnchor?: "top" | "middle" | "bottom";
+    /** Text direction: clockwise top-to-bottom or counter-clockwise bottom-to-top. */
+    vert?: "vert" | "vert270";
+    /** How body text flows around a DrawingML textbox (wp:wrap*). */
+    wrap?: WrapMode;
+    /** behindDoc: paint under the body text, never displace it. */
+    behind?: boolean;
+    /** wp:anchor @allowOverlap="0": Word shifts this shape clear of earlier
+     * overlapping floats rather than letting them overlap. Default true. */
+    allowOverlap?: boolean;
+    /** Wrap distances px (wp:anchor distT/B/L/R). */
+    dist?: {
+        t: number;
+        b: number;
+        l: number;
+        r: number;
+    };
+    /** a:xfrm rotation, degrees clockwise (rotates the whole box). */
+    rotation?: number;
+    /** Text insets px (bodyPr lIns/tIns/rIns/bIns); default 9.6/4.8. For
+     * non-rect preset geometries these INCLUDE the geometry's text-rectangle
+     * insets (ellipse: inscribed rect; diamond: middle-half rect). */
+    insets?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    /** Non-rect preset geometry: paint these outline paths (in a viewW x viewH
+     * space scaled to the shape box) instead of a rectangle. Each path carries
+     * its resolved fill colour (undefined = unfilled) and whether the shape's
+     * stroke applies to it. */
+    geom?: {
+        viewW: number;
+        viewH: number;
+        paths: {
+            d: string;
+            fill?: string;
+            stroke: boolean;
+        }[];
+    };
+    /** bodyPr a:noAutofit: the box does NOT grow with its text — Word hides
+     * whole lines that stick out past the shape bottom (phase23 p12 ovals:
+     * "Was 0 / B" visible, the wrapped tail rows hidden). */
+    clipText?: boolean;
+    /** bodyPr a:spAutoFit: the box grows in height to exactly fit its laid text
+     * plus the top/bottom insets (the stored cy is only Word's last cached
+     * value). Width is fixed. */
+    autofitHeight?: boolean;
+    /** bodyPr a:normAutofit — "shrink text on overflow". The mode is recorded
+     * because the fit report names it, NOT because it changes the layout:
+     * probe-shapefit measured fourteen normAutofit shapes through desktop Word
+     * and every one paints at its authored size and clips at the box bottom,
+     * exactly like a:noAutofit. `clipText` is set alongside this and is what the
+     * layout reads. */
+    shrinkText?: boolean;
+    /** Linked text-box chain id (wps:txbx/@id or wps:linkedTxbx/@id): boxes with
+     * the same id form one story. The seq-0 box (wps:txbx) holds the content;
+     * later boxes (wps:linkedTxbx, chainSeq>0) are empty sinks that continue the
+     * overflow. */
+    chainId?: string;
+    /** Position in the linked chain (0 = the content box). */
+    chainSeq?: number;
+    /** Source w:drawing element, attached at parse time so the shape's fill can
+     * be an interactive hit target (select the shape instead of the body text
+     * behind it). */
+    srcDrawing?: XmlElement;
+    /** Header/footer-owned textbox whose text is edited as an independent story. */
+    textboxStory?: boolean;
+    /** DrawingML WordArt, including the identity textNoShape preset. */
+    wordArt?: boolean;
+    /** WordArt glyph fill from w14:textFill or the fallback run color. */
+    wordArtFill?: string;
+    /** WordArt glyph alpha, 0..1. */
+    wordArtOpacity?: number;
+    /** bodyPr a:prstTxWarp preset name (textArchUp, textWave1, textChevron,
+     * textCirclePour, …): the shape's text is bent onto the preset's envelope
+     * rather than flowed as ordinary lines. "textNoShape" (no warp) is dropped. */
+    warp?: string;
+}
+/** WordArt (VML v:textpath, e.g. a "CONFIDENTIAL" watermark): text scaled to
+ * fill a box, optionally rotated, painted semi-transparent behind the body. */
+interface ShapeWordArt {
+    type: "wordart";
+    text: string;
+    fontFamily: string;
+    bold?: boolean;
+    italic?: boolean;
+    /** CSS fill color. */
+    fill: string;
+    /** 0..1 alpha. */
+    opacity: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+    hAlign?: "left" | "center" | "right";
+    vAlign?: "top" | "center" | "bottom";
+    /** Clockwise degrees. */
+    rotation: number;
+    behind?: boolean;
+    /** The source v:textpath font-size (px). */
+    fontSize?: number;
+    /** The referenced v:shapetype has a malformed text-guide path (missing
+     * coordinates), so Word collapses its horizontal glyph outlines into a thin
+     * vertical band instead of painting a box-filling watermark. */
+    noFit?: boolean;
+    /** Source VML shape element (v:shape / v:rect) for interactive editing:
+     * the v:textpath string, fill/opacity, and rotation live under it. */
+    src?: XmlElement;
+}
+interface ShapeArt {
+    type: "art";
+    srcDrawing?: XmlElement;
+    /** A freehand stroke, selectable by the Draw ribbon's stroke eraser. */
+    ink?: boolean;
+    x: number;
+    y: number;
+    /** Percent-of-page offsets (wp14:pctPos*Offset), 0..1. */
+    pctX?: number;
+    pctY?: number;
+    width: number;
+    height: number;
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+    hAlign?: "left" | "center" | "right";
+    vAlign?: "top" | "center" | "bottom";
+    behind?: boolean;
+    /** a:xfrm rotation, degrees clockwise. */
+    rotation?: number;
+    /** wp:wrapSquare/.../wrapTopAndBottom on the anchor (w10:wrap on a VML
+     * group): text wraps around the art as around a text box. */
+    wrap?: WrapMode;
+    /** wp:anchor dist* in px, used with `wrap`. */
+    dist?: {
+        t: number;
+        b: number;
+        l: number;
+        r: number;
+    };
+    lines: DrawingLine[];
+    images: DrawingImage[];
+    paths: DrawingPath[];
+    /** Positioned text bodies inside the group (wps textboxes, dsp:sp txBody). */
+    texts?: DrawingTextShape[];
+}
+/** How text interacts with a floating image. */
+type WrapMode = "square" | "topAndBottom" | "none";
+interface ShapeImage {
+    type: "image";
+    part: string;
+    /** Offset from the anchor origin, px. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+    /** Horizontal alignment when the file uses wp:align instead of an offset. */
+    hAlign?: "left" | "center" | "right";
+    /** Vertical alignment keyword (VML mso-position-vertical; watermarks center). */
+    vAlign?: "top" | "center" | "bottom";
+    wrap: WrapMode;
+    /** behindDoc anchors render under the text and never displace it. */
+    behind?: boolean;
+    /** Wrap distances px (wp:anchor distT/B/L/R); text clears the image by these. */
+    dist?: {
+        t: number;
+        b: number;
+        l: number;
+        r: number;
+    };
+    crop?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    rotation?: number;
+    /** Watermark "washout" recolor (VML v:imagedata gain/blacklevel, 0..1). */
+    washout?: {
+        gain: number;
+        blacklevel: number;
+    };
+    /** Source w:drawing element (editing). */
+    srcDrawing?: XmlElement;
+    model3D?: Model3DReference;
+    webVideo?: WebVideoReference;
+    embeddedObject?: EmbeddedObjectReference;
+}
+type Shape = (ShapeLine | ShapeTextbox | ShapeImage | ShapeArt | ShapeWordArt) & {
+    /** wp:anchor relativeHeight, used for object stacking order. */
+    z?: number;
+    /** Print with markup only: the shape's run is a tracked change, so the
+     * layout frames the shape's box in the author's color, struck through
+     * when the change is a deletion or a move away. The balloon and the
+     * change bar come from the run's changes, at the anchor's line. */
+    revision?: {
+        color: string;
+        struck: boolean;
+    };
+};
+/**
+ * Floating/anchored object: does not occupy inline space; positioned against
+ * page/margin/paragraph during layout. (How classic pleading paper draws its
+ * margin line numbers and vertical rules.)
+ */
+interface AnchorContent {
+    kind: "anchor";
+    shape: Shape;
+}
+/** A stroked segment inside a composite drawing, px relative to its box. */
+interface DrawingLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    color: string;
+    weight: number;
+    style?: "single" | "dotted" | "dashed";
+}
+interface DrawingImage {
+    part: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    crop?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    rotation?: number;
+    /** a:ln picture outline (Word draws it just outside the image). */
+    border?: {
+        color: string;
+        width: number;
+    };
+}
+/**
+ * Composite inline drawing (DrawingML groups): vector lines + placed images
+ * inside a width×height box that flows like an image.
+ */
+interface DrawingContent {
+    kind: "drawing";
+    width: number;
+    height: number;
+    lines: DrawingLine[];
+    images: DrawingImage[];
+    /** Native ChartML chart data resolved from the related chart part. */
+    chart?: ChartData;
+    /** Native SmartArt diagram data resolved from its diagram parts. */
+    smartArt?: SmartArtData;
+    /** Freeform vector shapes (a:custGeom), as SVG path data. */
+    paths?: DrawingPath[];
+    /** An INLINE wps text box (wp:inline wps:txbx): a fixed-extent box that
+     * flows in the text (occupying its width x height like an inline image) and
+     * carries a fill/border + its own block content. Distinct from the floating
+     * ShapeTextbox, which is absolutely placed via a wp:anchor. */
+    textbox?: {
+        blocks: Block[];
+        fill?: string;
+        stroke?: {
+            color: string;
+            weight: number;
+        };
+        insets?: {
+            l: number;
+            t: number;
+            r: number;
+            b: number;
+        };
+        textAnchor?: "top" | "middle" | "bottom";
+    };
+    /** Source w:drawing element (select/move as a group). */
+    srcDrawing?: XmlElement;
+    /** Positioned text bodies inside the drawing (multi-textbox groups and
+     * SmartArt cached-drawing shapes). Painted above lines/paths. */
+    texts?: DrawingTextShape[];
+}
+/** The c:chartSpace plot kinds the renderer paints. Anything else (3-D, radar,
+ * surface, stock, bubble) parses with `unsupported` set instead. */
+type ChartType = "column" | "bar" | "line" | "pie" | "doughnut" | "area" | "scatter";
+interface ChartSeries {
+    name: string;
+    values: number[];
+    /** c:xVal of a scatter series. Every other type shares one category axis,
+     * so only scatter carries per-series x values. */
+    xValues?: number[];
+    /** Explicit series fill/line from c:spPr, overriding the palette slot. */
+    color?: string;
+    /** Explicit c:dPt fills, keyed by point index (pie slices, single bars). */
+    pointColors?: Record<number, string>;
+    /** c:smooth — draw the line series through a spline instead of segments. */
+    smooth?: boolean;
+    /** c:spPr/a:ln/@w, in px. A line or scatter series says here how heavy its
+     * stroke is; a scatter series, whose stroke is optional, says it has one. */
+    lineWidth?: number;
+    /** c:marker/c:symbol, an ST_MarkerStyle name. "none" draws no marker, and a
+     * name with no shape behind it takes the series' slot in Word's sequence. */
+    markerSymbol?: string;
+    /** c:marker/c:size, the width across the marker in px. */
+    markerSize?: number;
+}
+type ChartTickMark = "none" | "in" | "out" | "cross";
+/** One axis of a 2-D chart (c:catAx/c:valAx/c:dateAx). */
+interface ChartAxis {
+    /** c:delete val="1": Word draws no line, ticks or labels for the axis. */
+    hidden?: boolean;
+    /** A c:majorGridlines child is present. */
+    gridlines?: boolean;
+    /** c:numFmt formatCode applied to the tick labels, e.g. "0.0%". */
+    format?: string;
+    title?: string;
+    /** c:scaling overrides of the automatic scale. */
+    min?: number;
+    max?: number;
+    majorUnit?: number;
+    /** c:scaling/c:orientation val="maxMin". */
+    reversed?: boolean;
+    /** c:majorTickMark / c:minorTickMark. The schema default is "out" for major
+     * and "none" for minor; Word writes both explicitly. */
+    majorTick?: ChartTickMark;
+    minorTick?: ChartTickMark;
+    /** c:tickLblPos val="none" keeps the axis but drops its labels. */
+    labels?: boolean;
+    /** c:crossBetween on a value axis, which decides where the category axis puts
+     * its points: "between" insets them by half a category (Word's choice for
+     * bar and column), "midCat" seats the first and last on the plot's edges
+     * (Word's choice for line and area). */
+    crossBetween?: "between" | "midCat";
+}
+interface ChartData {
+    type: ChartType;
+    /** Local name of a plot the renderer does not paint (bar3DChart, radarChart,
+     * …). When set, `type` is a placeholder and the renderer draws a labeled box
+     * rather than pretending the data is a column chart. */
+    unsupported?: string;
+    title?: string;
+    categories: string[];
+    series: ChartSeries[];
+    /** c:grouping — how bar/column/area series stack. */
+    grouping?: "clustered" | "stacked" | "percentStacked";
+    /** Legend edge. Absent when the chart has no c:legend. */
+    legend?: "l" | "r" | "t" | "b" | "tr";
+    /** c:dLbls showVal on the plot or on every series. */
+    dataLabels?: boolean;
+    /** c:varyColors — give each point of a single series its own palette slot. */
+    varyColors?: boolean;
+    categoryAxis?: ChartAxis;
+    valueAxis?: ChartAxis;
+    /** c:holeSize percent of a doughnut (Word's default is 75). */
+    holeSize?: number;
+    /** c:gapWidth percent between bar/column categories (Word's default is 150). */
+    gapWidth?: number;
+    /** c:overlap percent between bars of one category (Word: -27 clustered,
+     * 100 stacked). */
+    overlap?: number;
+    /** c:marker val="1" on a line chart: draw a point marker at each value. */
+    markers?: boolean;
+    /** Font size in px from c:title//a:defRPr@sz. Word's default title is 14pt. */
+    titleSize?: number;
+    /** Font size in px from c:txPr//a:defRPr@sz, the chart-wide text size. Word's
+     * default for axis labels, legend entries and data labels is 9pt. */
+    textSize?: number;
+}
+type SmartArtLayout = "process" | "cycle" | "hierarchy" | "list";
+interface SmartArtData {
+    layout: SmartArtLayout;
+    items: string[];
+}
+/** A text body positioned inside a composite drawing (a wps textbox in a
+ * group, or a SmartArt dsp:sp txBody), px relative to the drawing's box. */
+interface DrawingTextShape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    blocks: Block[];
+    /** Background fill painted behind the text box. */
+    fill?: string;
+    /** Outline. */
+    stroke?: {
+        color: string;
+        weight: number;
+    };
+    /** Text insets px (bodyPr lIns/tIns/rIns/bIns). */
+    insets: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    /** Vertical anchoring of the text inside the box (bodyPr anchor). */
+    textAnchor?: "top" | "middle" | "bottom";
+    /** DrawingML cached text paint-only baseline adjustment in px. */
+    paintOffsetY?: number;
+}
+interface DrawingPath {
+    /** Position/size inside the drawing, px. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** SVG path in the `viewW x viewH` source coordinate space. */
+    d: string;
+    viewW: number;
+    viewH: number;
+    fill?: string;
+    stroke?: {
+        color: string;
+        width: number;
+        opacity?: number;
+    };
+    /** Zero-based visible SmartArt node this path paints. */
+    smartArtNodeIndex?: number;
+}
+/**
+ * Footnote/endnote reference mark. In body text (w:footnoteReference /
+ * w:endnoteReference) `id` points into the notes part. Inside a note body,
+ * w:footnoteRef / w:endnoteRef render the note's own mark: `self` is true and
+ * `id` is meaningless.
+ */
+interface NoteRefContent {
+    kind: "noteRef";
+    noteType: "footnote" | "endnote";
+    id: number;
+    self?: boolean;
+    /** The document supplies the visible mark in the following run content. */
+    customMarkFollows?: boolean;
+}
+/** w:ruby — an East-Asian ruby (furigana) cluster: an annotation run (w:rt)
+ * riding above a base run (w:rubyBase). Both sides render as their own runs;
+ * the annotation is centered over the base and raised above its baseline. */
+interface RubyContent {
+    kind: "ruby";
+    base: Run;
+    rt: Run;
+    /** w:rubyPr/w:hpsRaise — annotation baseline raise above the base baseline,
+     * half-points. */
+    hpsRaise?: number;
+    /** w:rubyPr/w:rubyAlign — how the annotation distributes over the base. */
+    align?: "center" | "distributeLetter" | "distributeSpace" | "left" | "right" | "rightVertical";
+}
+type RunContent = MathContent | TextContent | BreakContent | TabContent | PTabContent | ImageContent | FieldContent | AnchorContent | DrawingContent | NoteRefContent | RubyContent;
+/**
+ * A tracked change a printed markup page shows beside its text (see
+ * pdf/comments.ts): what it is, in Word's words, and who made it when.
+ * Set only when the document is parsed for print with author colors.
+ */
+interface Revision {
+    /** Unique over the document: the element's kind and w:id. */
+    id: string;
+    kind: "ins" | "del" | "moveTo" | "moveFrom" | "format";
+    author: string;
+    /** ISO timestamp from w:date, verbatim. */
+    date?: string;
+    /** The balloon's text: "Inserted", "Deleted", "Moved from", "Moved to",
+     * "Inserted row", "Deleted row", "Formatted: Font: Bold", ... */
+    label: string;
+}
+interface Run {
+    type: "run";
+    props: RunProps;
+    content: RunContent[];
+    /** Source w:r element. */
+    src?: XmlElement;
+    /** The tracked changes this run is part of, or whose balloon anchors at
+     * it (a paragraph's, row's or table's format change is put on each of its
+     * runs). Print with markup only. */
+    changes?: Revision[];
+    /** Element whose children array contains src (w:p, w:hyperlink, …). */
+    srcParent?: XmlElement;
+}
+interface Hyperlink {
+    type: "hyperlink";
+    href?: string;
+    anchor?: string;
+    /** Complex HYPERLINK whose target contains nested fields. */
+    field?: FieldContent;
+    runs: Run[];
+}
+type ParaChild = Run | Hyperlink;
+interface Paragraph {
+    type: "paragraph";
+    props: ParaProps;
+    children: ParaChild[];
+    /** Section break attached to this paragraph's pPr (ends a section). */
+    sectionBreak?: SectionProps;
+    /** w:bookmarkStart names in this paragraph (PAGEREF targets). */
+    bookmarks?: string[];
+    /** Final revision view: the paragraph mark AND all content are tracked
+     * deletions — the paragraph does not exist (no line, no numbering). */
+    revisionHidden?: boolean;
+    /** Markup view: the paragraph mark itself is a tracked insertion or
+     * deletion (a suggested line break, or a suggested merge). Layout draws it
+     * as a pilcrow in the revision's colors after the paragraph's content; it is
+     * not text, so find, word count and the like never see it. */
+    markRevision?: "ins" | "del";
+    /** The mark's pilcrow color when the markup is printed with author colors. */
+    markRevisionColor?: string;
+    /** Print with markup only: the tracked changes anchored at the paragraph
+     * mark, which the layout's mark run carries so they get a balloon and a
+     * change bar — the mark's own insertion or deletion, and the body's final
+     * section change (w:sectPrChange) on the last paragraph. */
+    markChanges?: Revision[];
+    /** Source w:p element. */
+    src?: XmlElement;
+}
+interface TableCellProps {
+    /** Preferred width px (from tcW when dxa). */
+    width?: number;
+    /** Preferred width as a fraction of the table width (from tcW when pct). */
+    widthPct?: number;
+    /** The source explicitly declares tcW type="auto" (distinct from no tcW). */
+    widthAuto?: boolean;
+    gridSpan: number;
+    vMerge?: "restart" | "continue";
+    borders?: {
+        top?: Border;
+        bottom?: Border;
+        left?: Border;
+        right?: Border;
+        tl2br?: Border;
+        tr2bl?: Border;
+    };
+    shading?: string;
+    /** Cell margins px. */
+    margins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    verticalAlign?: "top" | "center" | "bottom";
+    textDirection?: "btLr" | "tbRl";
+}
+interface TableCell {
+    props: TableCellProps;
+    blocks: Block[];
+}
+interface TableRowProps {
+    /** Empty grid columns before/after the row's cells. */
+    gridBefore?: number;
+    gridAfter?: number;
+    /** Preferred widths in px of the omitted columns (wBefore/wAfter). */
+    widthBefore?: number;
+    widthAfter?: number;
+    /** px; undefined = auto */
+    height?: number;
+    heightRule?: "auto" | "atLeast" | "exact";
+    cantSplit?: boolean;
+    /** Repeat as header row on each page. */
+    tblHeader?: boolean;
+}
+interface TableRow {
+    props: TableRowProps;
+    cells: TableCell[];
+}
+interface TableProps {
+    styleId?: string;
+    /** px table indent from left margin. */
+    indent?: number;
+    alignment?: Alignment;
+    /** w:bidiVisual — RTL table: column order reverses and the table hugs the
+     * right margin. */
+    bidiVisual?: boolean;
+    borders?: {
+        top?: Border;
+        bottom?: Border;
+        left?: Border;
+        right?: Border;
+        insideH?: Border;
+        insideV?: Border;
+    };
+    /** Default cell margins px. */
+    cellMargins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /** w:tblCellSpacing px — old-style separated cell borders: every cell gets
+     * its own border box inset by this much from the grid slot on all sides
+     * (adjacent cells end up 2x apart), and the table outline is a separate box
+     * around everything. */
+    cellSpacing?: number;
+    /** w:tblpPr — floating table: absolutely positioned against page/margin/
+     * column, painted over an opaque white sheet, with body text (including
+     * text EARLIER in the flow on the same page) wrapping square around it. */
+    floating?: {
+        hAnchor: "page" | "margin" | "text";
+        vAnchor: "page" | "margin" | "text";
+        /** tblpX/tblpY px (absent when an alignment keyword is used). */
+        x?: number;
+        y?: number;
+        xAlign?: "left" | "center" | "right";
+        yAlign?: "top" | "center" | "bottom";
+        /** Wrap distances px (leftFromText, …). */
+        dist: {
+            l: number;
+            r: number;
+            t: number;
+            b: number;
+        };
+        /** w:tblOverlap "never": shift clear of earlier floating tables. */
+        allowOverlap: boolean;
+    };
+    /** Preferred total width px (tblW dxa) or undefined for auto. */
+    width?: number;
+    /** Preferred total width as a fraction of available width (tblW pct). */
+    widthPct?: number;
+    layout?: "fixed" | "autofit";
+    /** w:tblLook flags controlling which conditional formats apply. */
+    tblLook?: TableLook;
+}
+/** w:tblLook flags controlling which conditional table-style formats apply. */
+interface TableLook {
+    firstRow: boolean;
+    lastRow: boolean;
+    firstColumn: boolean;
+    lastColumn: boolean;
+    noHBand: boolean;
+    noVBand: boolean;
+}
+interface Table {
+    type: "table";
+    props: TableProps;
+    /** Column grid widths px (tblGrid). */
+    grid: number[];
+    rows: TableRow[];
+    /** Source w:tbl element. */
+    src?: XmlElement;
+}
+type Block = Paragraph | Table;
+interface HeaderFooterRefs {
+    default?: string;
+    first?: string;
+    even?: string;
+}
+interface ColumnSpec {
+    count: number;
+    /** Space between columns px. */
+    space: number;
+    /** Explicit widths px when equalWidth=false. */
+    widths?: number[];
+    /** Per-column trailing space px (w:col w:space), when explicit w:col
+     * entries are present. spaces[i] separates column i from column i+1. */
+    spaces?: number[];
+    /** w:cols w:sep: paint a vertical rule centered in each inter-column gap. */
+    sep?: boolean;
+}
+interface SectionProps {
+    pageWidth: number;
+    pageHeight: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    marginLeft: number;
+    /** Distance of header top from page top, px (w:headerReference distance). */
+    headerDistance: number;
+    footerDistance: number;
+    gutter: number;
+    headerRefs: HeaderFooterRefs;
+    footerRefs: HeaderFooterRefs;
+    /** Different first-page header/footer enabled. */
+    titlePage: boolean;
+    /** Page numbering restart value, if set. */
+    pageNumberStart?: number;
+    pageNumberFormat?: string;
+    columns: ColumnSpec;
+    /** w:docGrid type=lines/linesAndChars: minimum single-line height (px) that
+     * the line-spacing multiplier is applied over. Word snaps every line's font
+     * height up to this grid pitch (CJK documents). */
+    docGridLinePitch?: number;
+    /** Present w:docGrid type; omitted w:type means "default". */
+    docGridType?: "default" | "lines" | "linesAndChars" | "snapToChars";
+    /** w:docGrid type="charsAndLines": a combined char+line grid that (in compat
+     * 15) keeps natural East-Asian line pitch. Drives the CJK line-height
+     * correction during measurement. */
+    docGridCharGrid?: boolean;
+    type?: "nextPage" | "continuous" | "evenPage" | "oddPage" | "nextColumn";
+    /** Vertical alignment of page content. */
+    vAlign?: "top" | "center" | "both" | "bottom";
+    /** w:pgBorders. Offsets (border.space, px) measure from text or page edge. */
+    pageBorders?: {
+        top?: Border;
+        bottom?: Border;
+        left?: Border;
+        right?: Border;
+        offsetFrom: "text" | "page";
+    };
+    /** w:lnNumType: margin line numbering. distance px from the text edge.
+     * start is the raw w:start OFFSET (0 when the attribute is absent, its
+     * literal value otherwise) added to the running per-line count — see
+     * parse/section.ts for why an absent attribute isn't just "start 1". */
+    lineNumbering?: {
+        countBy: number;
+        start: number;
+        distance: number;
+        restart: "continuous" | "newPage" | "newSection";
+    };
+    /** Footnote/endnote mark numbering (w:footnotePr / w:endnotePr). */
+    footnoteNumFmt?: string;
+    footnoteNumStart?: number;
+    endnoteNumFmt?: string;
+    endnoteNumStart?: number;
+    /** w:numRestart: when the mark counter resets. Absent means "continuous"
+     * (the whole document shares one counter — this engine's only honored
+     * value; eachSect/eachPage are round-trip preserved but not laid out). */
+    footnoteNumRestart?: "continuous" | "eachSect" | "eachPage";
+    endnoteNumRestart?: "continuous" | "eachSect" | "eachPage";
+    /** w:pos: where the note text is placed. Round-trip preserved only — the
+     * layout always places footnotes at the page bottom and endnotes at the
+     * document end, regardless of this value. */
+    footnotePos?: "pageBottom" | "beneathText";
+    endnotePos?: "sectEnd" | "docEnd";
+    /** w:textDirection tbRl: the whole section flows as East-Asian vertical
+     * writing — lines run top-to-bottom, progressing right-to-left. */
+    textDirection?: "tbRl";
+}
+interface Section {
+    props: SectionProps;
+    blocks: Block[];
+}
+/** A review comment from word/comments.xml. */
+interface DocComment {
+    id: string;
+    author: string;
+    initials?: string;
+    /** ISO timestamp from w:date, verbatim. */
+    date?: string;
+    /** Plain text of the comment body (paragraphs joined with newlines). */
+    text: string;
+    /** w14:paraId of the comment's last body paragraph (threading key). */
+    paraId?: string;
+    /** Parent comment id when this comment is a reply (commentsExtended). */
+    parentId?: string;
+    /** Thread resolved (w15:commentEx w15:done="1" — the [MS-DOCX] CT_CommentEx
+     * extension; ECMA-376 itself has no resolved state). Meaningful on the
+     * thread parent; Word grays the whole thread from the parent's flag. */
+    resolved?: boolean;
+}
+/** A reviewer from word/people.xml (w15:person): the display name, and the
+ * identity the presence provider knows them by (w15:presenceInfo). */
+interface DocPerson {
+    author: string;
+    providerId?: string;
+    userId?: string;
+}
+/** A font file the package embeds (word/fonts/*.odttf), from fontTable.xml:
+ * a w:font's w:embedRegular, w:embedBold, w:embedItalic or w:embedBoldItalic. */
+interface DocEmbeddedFont {
+    /** The family the document names (w:font w:name). */
+    family: string;
+    bold: boolean;
+    italic: boolean;
+    /** The package part that holds the file. */
+    part: string;
+    /** The w:fontKey GUID the file is obfuscated with (ECMA-376 Part 1
+     * §17.8.1); absent when the file is a plain font. */
+    key?: string;
+}
+interface HeaderFooter {
+    blocks: Block[];
+}
+/** One w:tblStylePr conditional-formatting block (firstRow, band1Horz, …). */
+interface TableCondFormat {
+    /** Cell shading fill as CSS color. */
+    shd?: string;
+    /** Conditional cell borders. */
+    borders?: {
+        top?: Border;
+        bottom?: Border;
+        left?: Border;
+        right?: Border;
+        insideH?: Border;
+        insideV?: Border;
+    };
+    /** Conditional run bold (firstRow/firstCol headers). */
+    bold?: boolean;
+    /** Full conditional run props (w:tblStylePr > w:rPr). */
+    rPr?: RunProps;
+}
+type TableCondType = "wholeTable" | "band1Vert" | "band2Vert" | "band1Horz" | "band2Horz" | "firstRow" | "lastRow" | "firstCol" | "lastCol" | "nwCell" | "neCell" | "swCell" | "seCell";
+interface Style {
+    id: string;
+    type: "paragraph" | "character" | "table" | "numbering";
+    name?: string;
+    basedOn?: string;
+    isDefault?: boolean;
+    pPr?: ParaProps;
+    rPr?: RunProps;
+    tblPr?: TableProps;
+    /** w:tblStylePr conditional formats, by type (table styles only). */
+    condFormats?: Map<TableCondType, TableCondFormat>;
+    /** w:tblStyleRowBandSize / ColBandSize (default 1). */
+    rowBandSize?: number;
+    colBandSize?: number;
+}
+interface Styles {
+    byId: Map<string, Style>;
+    defaultParagraphStyle?: string;
+    defaultRPr: RunProps;
+    defaultPPr: ParaProps;
+}
+interface NumberingLevel {
+    ilvl: number;
+    start: number;
+    format: string;
+    /** Template like "%1." */
+    text: string;
+    alignment: Alignment;
+    /** Paragraph props contributed by the level (indents). */
+    pPr?: ParaProps;
+    rPr?: RunProps;
+    suffix: "tab" | "space" | "nothing";
+    restartAfter?: number;
+}
+interface AbstractNum {
+    id: number;
+    levels: Map<number, NumberingLevel>;
+    numStyleLink?: string;
+}
+interface NumInstance {
+    numId: number;
+    abstractNumId: number;
+    overrides: Map<number, {
+        startOverride?: number;
+        level?: NumberingLevel;
+    }>;
+}
+interface Numbering {
+    abstract: Map<number, AbstractNum>;
+    instances: Map<number, NumInstance>;
+}
+interface Theme {
+    majorFont: string;
+    minorFont: string;
+    majorBidiFont?: string;
+    minorBidiFont?: string;
+    /** East Asian faces from theme <a:ea> (fontScheme major/minorFont). Word's
+     * eastAsiaTheme="minor/majorEastAsia" resolves through these, NOT the Latin
+     * minor/major font — routing a CJK run's theme reference to the Latin face
+     * (Calibri) leaves East Asian text in a glyphless Latin font. */
+    majorEastAsiaFont?: string;
+    minorEastAsiaFont?: string;
+    colors: Map<string, string>;
+}
+
+/** A read-only view over the OPC (zip) package inside a .docx file. */
+declare class Package {
+    private files;
+    /** Every entry is held to ZipBudget before any is inflated. fflate
+     * inflates an entry into a buffer of the size the directory gives, so an
+     * entry whose data holds more stops there: memory stays within the
+     * budget, and the entry fails, or comes out cut short (an XML part then
+     * fails to parse). */
+    constructor(data: Uint8Array);
+    static from(data: ArrayBuffer | Uint8Array): Package;
+    /** A package over an already-unzipped entry map (DocxDocument.clone). */
+    static fromFiles(files: Record<string, Uint8Array>): Package;
+    has(name: string): boolean;
+    binary(name: string): Uint8Array | undefined;
+    text(name: string): string | undefined;
+    names(): string[];
+    /** Raw entry map (shared, do not mutate) — used for write-back. */
+    raw(): Record<string, Uint8Array>;
+    /** OPC part names never start with '/' inside the zip; tolerate both. */
+    private normalize;
+}
+
+/**
+ * Stable node identity for replicated editing.
+ *
+ * Positions on the wire cannot be object references, and numeric child paths
+ * shift under concurrent structural edits — so blocks (w:p, w:tbl) and runs
+ * (w:r) get stable numeric ids held in an in-memory side table. The table is
+ * identity-keyed and NEVER serialized into the XML: writing ids as attributes
+ * would dirty every part on open and break the byte-identical round-trip
+ * guarantee for untouched parts.
+ *
+ * Assignment is deterministic: a document-order walk over the given roots,
+ * so two replicas that parse the same document derive the same table. Nodes
+ * created later by edits get ids explicitly (locally via `assign`, or from a
+ * replicated edit that carries the originating client's allocation) — a
+ * re-walk after edits only fills gaps and never renumbers survivors, because
+ * the table is keyed by element identity and in-place XML mutation preserves
+ * identity across `refresh()`.
+ */
+type StableId = number;
+interface EncodedCaret {
+    blockId: StableId;
+    runId: StableId;
+    /** Offset in the run's WIRE space: cumulative through the run's inline
+     * content in document order, where each w:t contributes its text length
+     * and each inline separator (w:tab / w:br / w:cr) contributes ONE unit.
+     * Counting separators makes encoding ONE-TO-ONE: a caret at the end of
+     * the w:t before a tab and one at the start of the w:t after it are
+     * different physical positions and get different wire offsets — without
+     * the separator unit both collapsed to the same number and the decoder
+     * had to guess (review bug: boundary intents applied into the wrong w:t
+     * on remote replicas, and boundary-starting ranges always rejected). */
+    offset: number;
+}
+declare class StableIds {
+    private byEl;
+    private byId;
+    private next;
+    /** Document-order assignment over the given roots (typically
+     * `doc.editableRoots()`). Idempotent: elements that already have ids keep
+     * them; untracked ids are assigned in walk order. Call after load and
+     * after any edit that created tracked nodes without explicit ids. */
+    assignFromRoots(roots: XmlElement[]): void;
+    /**
+     * Assign ids inside the given subtrees only — the scoped counterpart of
+     * assignFromRoots, for an edit that is known to have created nodes in one
+     * or two paragraphs (dirty-scoped reconciliation, perf B9/B10).
+     *
+     * EQUIVALENCE (the property the scoped hot path rests on): this produces
+     * the same table a full assignFromRoots would, PROVIDED every tracked node
+     * outside the subtrees already has an id. Assignment is order-dependent —
+     * fresh nodes take sequential numbers from `next` in walk order — and a
+     * subtree walk visits exactly a contiguous slice of the document-order
+     * walk, in the same order. So the only way the two can disagree is an
+     * un-id'd node elsewhere that the full walk would have numbered first.
+     * That invariant holds inductively: load/importSidecar ids everything, and
+     * every apply either ids the nodes it creates (carried ids), reports
+     * document scope (full refresh + full assign), or creates nodes only
+     * inside the subtrees passed here. Callers that cannot establish it must
+     * fall back to assignFromRoots.
+     */
+    assignFromSubtrees(subtrees: XmlElement[]): void;
+    private walk;
+    /** Explicitly assign an id to a newly created node. Local edits allocate
+     * (`assign(el)`); applying a replicated edit installs the carried value
+     * (`assign(el, carriedId)`). Carried ids must not collide. */
+    assign(el: XmlElement, id?: StableId): StableId;
+    /** Force `el` to carry `id`, replacing any id it already has (e.g. one
+     * auto-assigned by a refresh() before a carried id could be installed).
+     * The previous id is retired. Throws if `id` is held by a different element. */
+    reassign(el: XmlElement, id: StableId): void;
+    /** Drop an element's mapping entirely; its id retires (never reused —
+     * `next` stays monotonic). Used before carried-id assignment: a refresh
+     * inside a mutation auto-assigns sequential ids to the nodes it created,
+     * and one of those autos can equal a LATER id of the same carried batch,
+     * which would make reassign throw on a perfectly good intent. No-op for an
+     * unmapped element. */
+    unassign(el: XmlElement): void;
+    private install;
+    idOf(el: XmlElement): StableId | undefined;
+    elOf(id: StableId): XmlElement | undefined;
+    /** Drop mappings for elements no longer reachable from the given roots
+     * (deleted content). Keeps the table from growing across long sessions.
+     * Ids of dropped elements are retired, never reused. */
+    prune(roots: XmlElement[]): void;
+    size(): number;
+    /** Snapshot the table as [id, element] pairs against a parallel clone of
+     * the tree: `pairs` maps originals→clones (as produced by walking original
+     * and cloned roots in step). Used by the reconciliation snapshot (plan
+     * doc 03) so a restore re-keys the table to the restored elements. */
+    captureForClone(originalToClone: Map<XmlElement, XmlElement>): Map<StableId, XmlElement>;
+    /** Replace the table wholesale from a captured mapping (restore path). */
+    restore(fromCapture: Map<StableId, XmlElement>, nextId: StableId): void;
+    nextId(): StableId;
+    /**
+     * Export the table as `(id, path)` pairs, where a path is the structural
+     * location of the id'd element within the given roots: `[rootIndex,
+     * childIndex, childIndex, …]`. This is the checkpoint ID sidecar (plan doc
+     * 03): it lets a replica that reloads a snapshot reproduce the exact id
+     * table — parse-order re-derivation cannot, because split-created nodes
+     * carry non-sequential ids. Also carries `next` so id allocation resumes
+     * consistently.
+     */
+    exportSidecar(roots: XmlElement[]): {
+        next: StableId;
+        entries: [StableId, number[]][];
+    };
+    /** Rebuild the table from a sidecar against freshly parsed roots (the
+     * snapshot the sidecar was exported from). Replaces any current mappings. */
+    importSidecar(roots: XmlElement[], sidecar: {
+        next: StableId;
+        entries: [StableId, number[]][];
+    }): void;
+    /** Encode a caret as wire-stable addresses. `t` is the w:t (or other text
+     * holder) the caret sits in; the run is its nearest tracked ancestor run,
+     * the block the nearest tracked block above that. Returns null when the
+     * position isn't inside id-tracked content (e.g. math internals) — such
+     * positions are not yet addressable on the wire. */
+    encodeCaret(t: XmlElement, offset: number, parentOf: (el: XmlElement) => XmlElement | null): EncodedCaret | null;
+    /** Resolve an encoded caret back to a concrete (w:t, offset) in THIS
+     * table's tree — the inverse of encodeCaret, for restoring a caret across
+     * a reconciliation reload (the ids survive via the sidecar; the node
+     * references do not). When the exact run is gone (deleted or replaced by
+     * a concurrent edit) the caret falls back to the block's first text; null
+     * when nothing addressable remains. */
+    decodeCaret(pos: EncodedCaret): {
+        t: XmlElement;
+        offset: number;
+    } | null;
+}
+
+interface ParseContext {
+    theme?: Theme;
+    /** Tracked-changes display: "final" hides deletions and shows insertions
+     * plain (default); "markup" colors both. */
+    revisionView?: "final" | "markup";
+    /** Markup printed with Word's author colors: each author's color, in the
+     * order the authors first appear; a run in a change records the change
+     * (Run.changes). Absent, the markup view colors insertions green and
+     * deletions red for every author, as the editor shows them. */
+    revisionColor?: (author: string) => string;
+}
+
+interface Relationship {
+    id: string;
+    type: string;
+    target: string;
+    external: boolean;
+}
+type Relationships = Map<string, Relationship>;
+
+interface DocParseContext extends ParseContext {
+    rels: Relationships;
+    /** Text boxes parsed from a header/footer part edit as independent stories. */
+    independentTextboxStories?: boolean;
+    /** Read another package part's XML (SmartArt cached drawings live in
+     * word/diagrams/drawing*.xml, reachable only through the data part). */
+    readPart?: (part: string) => XmlElement | undefined;
+    /** Cross-reference bookmark capture: Word's Insert-Cross-Reference targets
+     * are `_RefNNN` bookmarks whose range delimits the referenced text (e.g. a
+     * caption's "Figure " + SEQ field). REF fields re-render that text at
+     * layout time — the docx cache is stale. `open` is keyed by bookmark id
+     * while the range is unclosed; `byName` keeps the finished run lists. */
+    refBookmarks?: {
+        open: Map<string, Run[]>;
+        byName: Map<string, Run[]>;
+    };
+}
+
+/** The two note parts a document can carry — see notePartsHolding. */
+type NotePart = "footnotes" | "endnotes";
+interface FromFilesOptions {
+    /** Build the header and footer block models (`headers`, `footers`). Default true. */
+    headerFooterBlocks?: boolean;
+    /** Tracked-changes display from the start, so the parts parsed at load
+     * (headers, footers, notes) follow it too. Default "final". */
+    revisionView?: "final" | "markup";
+    /** Print markup: each author's changes in Word's color for that author,
+     * and every change recorded on its runs (see Revision). */
+    revisionColors?: boolean;
+    /** With revisionColors: false gives every author's changes the first
+     * color, red, so that no color tells one author from another (print
+     * without authors). Default true. */
+    revisionAuthors?: boolean;
+}
+declare class DocxDocument$1 {
+    /** Changes whenever refresh() rebuilds the parsed model. Plain in-place text
+     * edits can keep this stable so incremental layout reuses model-only caches. */
+    private _modelVersion;
+    private _packageResourceVersion;
+    get modelVersion(): number;
+    /** Invalidate layout derived from related parts such as ChartML. */
+    markPackageResourceChanged(): void;
+    readonly pkg: Package;
+    readonly theme: Theme;
+    styles: Styles;
+    numbering: Numbering;
+    sections: Section[];
+    /** Header/footer parts keyed by relationship id from document.xml.rels.
+     * Empty when the document was opened without them (fromFiles). */
+    readonly headers: Map<string, HeaderFooter>;
+    readonly footers: Map<string, HeaderFooter>;
+    private readonly headerFooterBlocks;
+    /** Note content by note id. */
+    readonly footnotes: Map<number, Block[]>;
+    readonly endnotes: Map<number, Block[]>;
+    /** The separator paragraph controls the gap between its rule and the first
+     * footnote. */
+    readonly footnoteSeparator: Block[];
+    /** The w:continuationSeparator footnote: it opens a note area that starts
+     * with a note continued from the previous page. */
+    readonly footnoteContinuationSeparator: Block[];
+    /** `_Ref` cross-reference bookmark ranges (name → captured runs). REF
+     * fields re-render the referenced text from these — Word recomputes REF on
+     * open, so the cached field result in the file is stale. */
+    refBookmarks: Map<string, Run[]>;
+    readonly documentRels: Relationships;
+    /** settings.xml w:evenAndOddHeaders — enables the "even" header/footer variants. */
+    readonly evenAndOddHeaders: boolean;
+    /** settings.xml w:autoHyphenation (§17.15.1.10). This engine's layout does
+     * not hyphenate automatically — the setting is round-trip state that
+     * governs Word's own rendering of the document. */
+    readonly autoHyphenation: boolean;
+    /** settings.xml w:hyphenationZone/@w:val in twips (§17.15.1.53); null when
+     * the document does not declare one (Word defaults to 360 = 0.25"). */
+    readonly hyphenationZoneTwips: number | null;
+    /** settings.xml w:doNotHyphenateCaps (§17.15.1.41). */
+    readonly doNotHyphenateCaps: boolean;
+    /** settings.xml w:mirrorMargins — facing-page (book fold) margins: even
+     * (verso) pages swap the left/right margins and place the gutter on the
+     * inside (right) edge so the binding margin stays on the inner side of
+     * each spread. */
+    readonly mirrorMargins: boolean;
+    /** settings.xml w:compat w:suppressTopSpacing: the first line of a page
+     * takes its character height, not its authored (exact) line spacing. */
+    readonly suppressTopSpacing: boolean;
+    /** settings.xml w:defaultTabStop in px (Word default 0.5"). */
+    readonly defaultTabStop: number;
+    /** settings.xml w:compat compatibilityMode (12=Word2007, 14=Word2010,
+     * 15=Word2013+). Word 2013 (mode 15) introduced suppressing a paragraph's
+     * space-before when it lands at the top of a page; mode 14 and earlier keep
+     * it (nccih: a Heading1/2 after a page break sits at margin + its before).
+     * Absent → treated as current (15). */
+    readonly compatibilityMode: number;
+    /** The compatibilityMode settings.xml actually declares, or undefined when
+     * the setting (or settings.xml itself) is missing. `compatibilityMode`
+     * defaults an omitted value to 15, but a table's percentage width needs the
+     * distinction: Word fits the horizontal cell margins inside the table box at
+     * an EXPLICIT 15 and adds them around it when the setting is absent. */
+    readonly declaredCompatibilityMode: number | undefined;
+    /** settings.xml m:mathPr/m:defJc — default justification for display
+     * equations whose m:oMathParaPr carries no explicit m:jc (Word default:
+     * centerGroup — the rows of a broken equation left-align to each other and
+     * the group is centered in the column). */
+    readonly mathDefJc: "left" | "right" | "center" | "centerGroup";
+    /** settings.xml m:mathPr/m:wrapIndent in px (Word default 1440tw = 1"):
+     * indent of auto-wrapped display-equation continuation rows from the
+     * equation group's left edge (dense p13: the "+Dc(...)" continuations sit
+     * exactly 72pt right of the explicit rows). */
+    readonly mathWrapIndent: number;
+    /** Review comments from word/comments.xml (empty when the part is absent).
+     * Re-derived from the retained comments XML on every refresh(). */
+    comments: DocComment[];
+    /** The reviewers word/people.xml names (empty when the part is absent). */
+    readonly people: DocPerson[];
+    /** The font files the package embeds, as fontTable.xml lists them (empty when it embeds none). */
+    readonly embeddedFonts: DocEmbeddedFont[];
+    /** Retained comments.xml tree (editing + save round-trip), when present. */
+    private commentsPart;
+    private commentsRoot;
+    /** Retained commentsExtended.xml tree (comment threading), when present. */
+    private commentsExtPart;
+    private commentsExtRoot;
+    private commentsExtDirty;
+    /** Conditional table formats per table style id, keyed by the Styles object
+     * so re-parsing styles.xml (edits) naturally invalidates the cache. */
+    private tableCondCache;
+    /** Retained styles.xml tree (built-in style injection + save). */
+    private stylesPart;
+    private stylesRoot;
+    /** Retained numbering.xml tree (list creation + save round-trip). */
+    private numberingPart;
+    private numberingRoot;
+    private numberingDirty;
+    /** Retained footnotes.xml tree (footnote insertion + save round-trip). */
+    private footnotesPart;
+    private footnotesRoot;
+    private footnotesDirty;
+    private footnotesRels;
+    /** Retained endnotes.xml tree (endnote insertion + save round-trip). */
+    private endnotesPart;
+    private endnotesRoot;
+    private endnotesDirty;
+    private endnotesRels;
+    /** Retained bibliography sources part (the customXml b:Sources data of
+     * ECMA-376 §22.6), when present. Source-management editing mutates this
+     * tree in place; a document with none gets the part on first create. */
+    private sourcesPart;
+    private sourcesRoot;
+    private sourcesDirty;
+    /** Companion parts written when THIS session created the sources part
+     * (itemProps + its .rels); an arriving part keeps its own companions. */
+    private sourcesAux;
+    /** Retained glossary document part (word/glossary/document.xml, ECMA-376
+     * §17.12: glossaryDocument/docParts/docPart — Word's Quick Parts / Building
+     * Blocks store), when present. Building-block editing mutates this tree in
+     * place; a document with none gets the part on first create. Unlike
+     * headers/footers, a docPart's body is never caret-editable — it is only
+     * ever cloned INTO the main document body (insertBuildingBlock) or captured
+     * OUT of a selection (createBuildingBlock) — so this part carries no
+     * editableRoots()/stable-id integration of its own. */
+    private glossaryPart;
+    private glossaryRoot;
+    private glossaryDirty;
+    /** Serialize retained optional parts only once actually mutated, keeping
+     * untouched parts byte-identical through save(). */
+    private stylesDirty;
+    private commentsDirty;
+    /** Retained XML roots — source of truth for editing and save(). */
+    private readonly docPart;
+    /** Retained settings.xml tree. A synthetic empty root keeps history root
+     * indices stable for documents that did not originally contain the part. */
+    private readonly settingsPart;
+    private readonly settingsRoot;
+    private settingsDirty;
+    /** Parsed document.xml root (read-only outside the class; the layout engine
+     * scans it for incremental-reuse eligibility, tests walk it). */
+    readonly docRoot: XmlElement;
+    private readonly hfParts;
+    private readonly ctxBase;
+    /** Tracked-changes display mode; refresh() re-derives after changes. */
+    revisionView: "final" | "markup";
+    /** The revision authors in the order they first appeared, for revisionColor. */
+    private readonly revisionAuthors;
+    /** FromFilesOptions.revisionAuthors. */
+    private revisionAuthorColors;
+    private readonly relsPath;
+    private relsRoot;
+    private contentTypesRoot;
+    /** A fingerprint of the canonical XML first parsed from each always-modeled
+     * package part. If the retained tree still matches on save, keep the part's
+     * original bytes instead of replacing producer formatting such as CRLF line
+     * ends. A fingerprint and not the XML itself: the XML was a second copy of
+     * every document part, 30 MB for a 0.85 MB .docx. */
+    private readonly originalModeledXml;
+    private docPrIdCounter;
+    /** Transient layout state: set by the engine while laying out a docGrid
+     * type="charsAndLines" section so line measurement can give East-Asian
+     * glyphs their true (uninflated) grid line height. Off outside such a
+     * section. Safe as document-scoped mutable state because layout is
+     * single-threaded and sequential per section. */
+    charGridEa: boolean;
+    protected constructor(pkg: Package, options?: FromFilesOptions);
+    private readonly coreProperties;
+    /** Resolve the content controls under `root` as the document's own were
+     * resolved when it loaded, for body XML parsed outside it (stream/body.ts). */
+    hydrateControls(root: XmlElement): void;
+    /** Resolve content controls mapped to standard package core properties.
+     * Word refreshes these bindings on open, so the serialized sdtContent can
+     * be stale even though the visible value comes from docProps/core.xml. */
+    private hydrateCorePropertyControls;
+    /** Repair only objects emitted by older WordInWeb builds that Word rejects. */
+    private repairLegacyWordInWebObjects;
+    /**
+     * Re-derive the document model from the retained XML trees. Called after
+     * edit commands mutate the XML.
+     */
+    /** An author's revision color: Word's "by author" palette, given out in
+     * the order the authors first appear (the parts parsed at load, headers,
+     * footers and notes, before the body), the ninth author taking the first
+     * color again. Without authors (FromFilesOptions.revisionAuthors), the
+     * first color for all. */
+    revisionColor(author: string): string;
+    /** Switch tracked-changes display and re-derive the model. */
+    setRevisionView(view: "final" | "markup"): void;
+    /** Invalidated on refresh; see layoutGlobalSig. */
+    private _layoutGlobalSig;
+    /** Signature of everything OUTSIDE a paragraph's own XML that affects how it
+     * breaks into lines: style + numbering definitions, doc-level layout scalars,
+     * and the tracked-changes view mode. The line-break cache (layout/inline.ts)
+     * combines this with a paragraph's own content signature so a style/numbering/
+     * settings edit invalidates cached breaks even though the paragraph XML is
+     * unchanged. Memoized until the next refresh() (styles/numbering trees are
+     * stable across a plain text edit). */
+    layoutGlobalSig(): string;
+    refresh(): void;
+    /** Stable node-id side table for replicated editing. Null (and zero cost)
+     * for local-only documents; call `enableStableIds()` to populate and
+     * maintain it. Kept in memory only — never serialized into the XML. */
+    stableIds: StableIds | null;
+    /** Populate the stable-id table from current content and keep it updated
+     * on every subsequent refresh(). Idempotent. */
+    enableStableIds(): StableIds;
+    /** Reparse the two sibling body-story paragraphs created by Enter without
+     * rebuilding the complete document model. Paragraphs nested in table cells
+     * are included because legal documents spend most of their body inside
+     * tables; revisions, bookmarks, fields, and section breaks use refresh(). */
+    reparseDirectBodyParagraphSplit(beforeSource: XmlElement, afterSource: XmlElement): {
+        before: Paragraph;
+        after: Paragraph;
+    } | null;
+    /**
+     * The parsed body-story block list holding the paragraph parsed from
+     * `source`, and its index in it — searching sections and, recursively,
+     * table cells. Null when the model doesn't hold that paragraph (it lives in
+     * a header/footer/footnote part, or the model predates its creation), which
+     * is every targeted-reparse helper's signal to fall back to a full
+     * refresh(). Shared by those helpers and by paragraphBySource.
+     */
+    private locateParagraph;
+    private _paraLoc;
+    /** The parsed Paragraph for a retained w:p in the body story (table cells
+     * included), or null when the model doesn't hold it. Lets a caller that
+     * already knows which paragraph an edit addresses reach that paragraph's
+     * runs without walking the whole model. */
+    paragraphBySource(source: XmlElement): Paragraph | null;
+    /** Insert a new paragraph immediately before a retained body paragraph
+     * without rebuilding the complete document model. Used by Enter at the
+     * exact paragraph start, where the existing paragraph itself is unchanged. */
+    insertDirectBodyParagraphBefore(referenceSource: XmlElement, insertedSource: XmlElement): Paragraph | null;
+    /** Reparse a body paragraph plus several new siblings created by
+     * click-and-type without rebuilding the complete document model. */
+    reparseDirectBodyParagraphSplits(beforeSource: XmlElement, afterSources: XmlElement[]): Paragraph[] | null;
+    /** Reparse one retained body-story paragraph after a structural edit that
+     * leaves its surrounding block list unchanged, such as inserting ink. */
+    reparseBodyParagraph(source: XmlElement): Paragraph | null;
+    /** Reparse two sibling body-story paragraphs after Backspace/Delete merged
+     * their XML into one. Keeps the parsed model generation stable so long
+     * documents can use incremental layout instead of repaginating in full. */
+    reparseDirectBodyParagraphMerge(beforeSource: XmlElement, afterSource: XmlElement, survivorSource: XmlElement): Paragraph | null;
+    private deriveComments;
+    /** Retained comments tree for edit commands (null when the doc has none). */
+    /**
+     * Retained comments tree. With create=true, a missing comments.xml part is
+     * created and registered (content type + document relationship) so newly
+     * added comments serialize and round-trip through Word.
+     */
+    commentsTree(create?: boolean): XmlElement | null;
+    /**
+     * Make sure a paragraph style is usable: Word ships built-in definitions
+     * for Heading 1-6/Title even when a file doesn't declare them, so applying
+     * one to such a file must inject a standard definition (otherwise the
+     * paragraph would reference an undefined style and render as Normal).
+     */
+    ensureParagraphStyle(styleId: string): boolean;
+    /**
+     * Retained numbering tree. With create=true, a missing numbering.xml part
+     * is created and registered (content type + document relationship) so list
+     * definitions added by editing serialize and round-trip.
+     */
+    numberingTree(create?: boolean): XmlElement | null;
+    markNumberingChanged(): void;
+    /** Retained styles.xml tree, or null when the package has no styles part.
+     * Style-definition editing mutates this tree in place. */
+    stylesTree(): XmlElement | null;
+    /**
+     * Re-resolve the style cascade after a definition changed in place.
+     *
+     * A style definition is not addressed by any paragraph's XML, so mutating one
+     * changes how EVERY paragraph resolves without changing a single w:p. Two
+     * things therefore have to be reset by hand: the parsed Styles map every
+     * effective-props call reads, and layoutGlobalSig, which is what makes the
+     * line-break cache treat cached breaks for unchanged paragraph XML as stale.
+     */
+    markStylesChanged(): void;
+    /**
+     * Retained bibliography sources tree (b:Sources), or null when the package
+     * has no sources part. With create=true, a missing part is created and
+     * registered the way Word lays one out (ECMA-376 §22.6 + Part 2 custom XML
+     * data storage): the data itself as customXml/itemN.xml, a datastore-item
+     * properties part (itemPropsN.xml) declaring the Bibliography schema URI as
+     * its schemaRef, a .rels from the item to its properties, a customXml
+     * relationship from the main document part, and the content-type overrides.
+     *
+     * DETERMINISM. Everything written is a pure function of the package —
+     * the item number is the first free one, and the datastore itemID GUID is a
+     * fixed constant rather than Word's random draw — so two replicas creating
+     * the part through the same sequenced operation write identical bytes.
+     */
+    sourcesTree(create?: boolean): XmlElement | null;
+    /**
+     * Invalidate what a sources-part edit changes downstream. Like
+     * markStylesChanged, the part is addressed by no paragraph's XML: a
+     * CITATION field's painted text resolves from the part at layout, so the
+     * layout signature has to drop for unchanged paragraph XML to repaint.
+     */
+    markSourcesChanged(): void;
+    /**
+     * Retained glossary document tree (w:glossaryDocument), or null when the
+     * package has no glossary part. With create=true, a missing part is
+     * created and registered — package part, document relationship,
+     * content-type override — the createNotesPart discipline.
+     *
+     * The glossary part gets none of the sources part's companion machinery
+     * (no datastore item, no random itemID): it is an ordinary WordprocessingML
+     * part named by relationship TYPE, so creation just mints an empty
+     * `<w:glossaryDocument><w:docParts/></w:glossaryDocument>` and wires it up
+     * — closer to createNotesPart than to sourcesTree. A real Word-authored
+     * glossary part additionally carries its own styles.xml / settings.xml /
+     * fontTable.xml; this engine writes none of them, because a docPart's
+     * content is read once — to clone its blocks into the main document, where
+     * they resolve styles against the MAIN document's own styles.xml — and is
+     * never laid out or rendered as its own story the way a header/footer is.
+     *
+     * DETERMINISM: nothing here depends on Word's random draws (no GUID is
+     * written at all — w:docPartPr/w:guid is optional and this engine never
+     * reads it back), so two replicas creating the part through the same
+     * sequenced operation write identical bytes.
+     */
+    glossaryTree(create?: boolean): XmlElement | null;
+    /** Invalidate what a glossary-part edit changes: nothing downstream, since
+     * createBuildingBlock/deleteBuildingBlock touch only the glossary tree, not
+     * any paragraph the layout reads. Exists for the same "explicit intent to
+     * persist" reason markSourcesChanged does. */
+    markGlossaryChanged(): void;
+    /**
+     * Retained footnotes tree. With create=true, a missing footnotes.xml part
+     * is created and registered (with Word's required separator footnotes) so
+     * inserted footnotes serialize and round-trip.
+     */
+    footnotesTree(create?: boolean): XmlElement | null;
+    /** Retained endnotes tree; the endnote mirror of footnotesTree. */
+    endnotesTree(create?: boolean): XmlElement | null;
+    /** Register a new notes part in document.xml.rels and [Content_Types].xml,
+     * and return the part path. The tree itself is the caller's. */
+    private createNotesPart;
+    /**
+     * Create an empty header/footer part (with a default-type reference in
+     * every sectPr) when the document has none - Word does this implicitly the
+     * first time you edit the header area. Returns the part's root.
+     */
+    /** Whether the document declares any section properties at all. A blank
+     * minimal document has none; see ensureHfPart. */
+    private hasSectPr;
+    /** Whether a header (or footer) part already exists — the precondition
+     * `ensureHfPart` tests internally, exposed so a caller can tell a real
+     * creation from a no-op before mutating (the collab apply needs to know
+     * whether an ensureHeaderFooter intent has anything to do). */
+    hasHfPart(kind: "header" | "footer"): boolean;
+    ensureHfPart(kind: "header" | "footer"): XmlElement;
+    /** A w:headerReference / w:footerReference element. */
+    private hfReference;
+    /** Materialize the default body-level sectPr when the document declares no
+     * section properties at all (schema: the body's sectPr is its LAST child). */
+    private ensureBodySectPr;
+    /**
+     * Give every section a header and footer reference of the given variant
+     * type, creating one empty part per band the way Word does the first time
+     * "different first page" (type "first") or "different odd & even pages"
+     * (type "even") is enabled. Sections that already carry a reference of the
+     * type keep it — and its part's content. True when anything was added.
+     */
+    ensureHfVariantParts(type: "first" | "even"): boolean;
+    /**
+     * A new empty header or footer part, referenced as `type` from `sectPr`
+     * alone. Returns the part's target, as headerFooterRoot and
+     * relationshipsOf take it. compareDocuments gives a header the revised
+     * document lost one of these, to hold the original's content struck.
+     */
+    addHfPart(kind: "header" | "footer", type: "default" | "first" | "even", sectPr: XmlElement): string;
+    /** Create and register a new empty header/footer part — package part,
+     * document relationship, content-type override, hfParts entry — with no
+     * section references of its own; the caller decides which sectPrs point at
+     * it and with which w:type. */
+    private createHfPart;
+    markFootnotesChanged(): void;
+    markEndnotesChanged(): void;
+    /** Re-derive both id -> blocks maps from the retained trees, so layout sees
+     * an inserted or edited note. */
+    private rederiveNotes;
+    /** Called by comment edit commands after mutating the comments tree. */
+    markCommentsChanged(): void;
+    /**
+     * Retained commentsExtended tree (threading). With create=true, a missing
+     * part is created and registered (content type + document relationship) so
+     * Word picks up reply threading.
+     */
+    commentsExtendedTree(create?: boolean): XmlElement | null;
+    markCommentsExtendedChanged(): void;
+    /**
+     * The w:t elements covered by each comment's range, in document order.
+     * Point comments (a bare commentReference with no range) anchor to the
+     * nearest preceding w:t.
+     */
+    commentAnchors(): Map<string, XmlElement[]>;
+    /** Flag a notes part dirty when `t` lives inside it, so save()
+     * re-serializes footnotes.xml / endnotes.xml. Called by the editor after a
+     * text edit; a no-op for body/header/footer targets. */
+    markDirtyIfFootnote(t: XmlElement): void;
+    /**
+     * Which note parts hold `el` right now. An operation that DETACHES `el` —
+     * accepting or rejecting a revision, for one — has to ask BEFORE it mutates
+     * and mark the answer afterwards: a detached element belongs to no part, so
+     * a containment test run after the fact reports nothing and save() then
+     * leaves the stale footnotes.xml / endnotes.xml in the package.
+     */
+    notePartsHolding(el: XmlElement): NotePart[];
+    /** Flag the given note parts dirty, so save() re-serializes exactly those. */
+    markNotePartsChanged(parts: readonly NotePart[]): void;
+    /** The mutable XML roots (document body, related modeled parts, settings).
+     * settingsRoot is always second and always present so its history snapshot
+     * index stays stable even when optional related roots are created later. */
+    editableRoots(): XmlElement[];
+    /** CT_Settings children that precede w:mirrorMargins in the schema sequence
+     * (§17.15.1.78). Insertions go before the first child that is not a
+     * predecessor, so Word never has to repair settings.xml. */
+    private static readonly SETTINGS_BEFORE_MIRROR;
+    /** The schema predecessors of w:evenAndOddHeaders (§17.10.1): everything up
+     * to mirrorMargins, then the sequence through defaultTableStyle. */
+    private static readonly SETTINGS_BEFORE_EVEN_AND_ODD;
+    /** Set or remove one settings.xml element at its schema position. Null
+     * removes; otherwise the element is (re)inserted before the first child
+     * that is not a schema predecessor. */
+    private setSettingsElement;
+    /** Set or remove one on/off settings.xml toggle at its schema position. */
+    private setSettingsToggle;
+    /** The schema predecessors of w:autoHyphenation: everything through
+     * w:defaultTabStop (§17.15.1.78). Its cluster mates append in order. */
+    private static readonly SETTINGS_BEFORE_AUTO_HYPHENATION;
+    /**
+     * Patch the hyphenation settings (w:autoHyphenation §17.15.1.10,
+     * w:hyphenationZone §17.15.1.53, w:doNotHyphenateCaps §17.15.1.41). Each
+     * present key is written; `zoneTwips: null` removes the zone element. True
+     * when anything changed — the honest no-op a replicated document-scoped
+     * operation needs. This engine's layout does not hyphenate automatically;
+     * the settings govern Word's own rendering of the file.
+     */
+    setHyphenation(patch: {
+        auto?: boolean;
+        zoneTwips?: number | null;
+        noCaps?: boolean;
+    }): boolean;
+    /** Toggle the document-global facing-page margin mode in settings.xml. */
+    setMirrorMargins(enabled: boolean): void;
+    /** Toggle w:evenAndOddHeaders (§17.10.1) — the document-global switch that
+     * makes even pages use the "even" header/footer variants. */
+    setEvenAndOddHeaders(enabled: boolean): void;
+    /** Register settings.xml in document.xml.rels and [Content_Types].xml when
+     * the package was born without it (a minimal document). */
+    private registerSettingsPart;
+    /**
+     * Find the parent element of `target` in any modeled XML tree (document
+     * body, headers, footers). Linear scan — documents are small and this only
+     * runs on structural edits (Enter, paragraph merge).
+     */
+    /** The header part roots, in package order. A watermark is authored into
+     * every one of them: Word paints it on every page, and a document with a
+     * first-page or even-page header has more than one header part. */
+    /** The root of the header or footer part at `target`, if this document has one. */
+    headerFooterRoot(target: string): XmlElement | undefined;
+    headerRoots(): XmlElement[];
+    /** The footer part roots, in package order — headerRoots' counterpart, for
+     * operations that walk both bands (the page-number gallery's removal
+     * sweep). */
+    footerRoots(): XmlElement[];
+    /** XML roots that can carry tracked changes: body, headers/footers, notes. */
+    revisionRoots(): XmlElement[];
+    /** Body, header/footer and note roots — every tree the caret can reach. */
+    private contentRoots;
+    /**
+     * Memoized child→parent links. Nothing invalidates this map — the tree is
+     * spliced constantly — so every answer is RE-DERIVED before it is returned:
+     * the memoized parent must still list the target among its children, and
+     * must still hang off a root (see memoIsLive). A stale entry can then only
+     * cost a cache miss, never a wrong answer.
+     *
+     * Both halves are needed. Containment alone is not proof of a live parent:
+     * a run split for formatting is spliced OUT of its paragraph while its own
+     * `children` array still lists the elements that moved into the replacement
+     * runs, so a containment-only check would hand back the detached run where a
+     * walk from the roots finds the new one.
+     */
+    private _parentMemo;
+    private memoIsLive;
+    findParentOf(target: XmlElement): XmlElement | undefined;
+    /** Record a parent link the caller just created (a splice), so the next
+     * lookup skips the full-document walk. Advisory only — findParentOf
+     * verifies every memo against the live tree before trusting it. */
+    noteParent(child: XmlElement, parent: XmlElement): void;
+    /**
+     * Serialize the (possibly edited) document back to .docx bytes. Only the
+     * XML parts we model are re-serialized; every other part round-trips
+     * byte-for-byte.
+     */
+    private rememberOriginalXml;
+    private writeModeledXml;
+    /**
+     * Canonicalize producer shorthand that Google Docs otherwise interprets as
+     * a fixed, few-twip table. Word treats `tblW="100%"` plus a placeholder
+     * grid as autofit; Google needs the standard pct value and a usable cached
+     * grid. The cached widths follow the same content-dominant shape and do not
+     * change Word's autofit result.
+     */
+    /** Undo closures recorded by save-time fixups while `saveJournal` is
+     * active, so `save()` can revert every live-tree mutation and remain
+     * side-effect-free. Collaborative checkpoints re-serialize the
+     * authoritative document repeatedly; a save that mutated the tree would
+     * change its hash outside the intent stream and desync the fleet. */
+    private saveJournal;
+    private journalSetAttr;
+    private normalizePercentageTableGrids;
+    save(): Uint8Array;
+    /**
+     * An independent copy: what `DocxDocument.load(doc.save())` gives, without
+     * zipping the package and unzipping it again. compareDocuments starts from a
+     * copy of the revised document, and the round trip through the zip was a
+     * third of its time on a document that had not changed at all.
+     */
+    clone(): DocxDocument$1;
+    /**
+     * The package's parts as save() writes them, before they are zipped: a
+     * writer that streams the zip to disk (compare-cli) takes them one at a
+     * time, without a zip of them all in memory and its unzip.
+     */
+    saveFiles(): Record<string, Uint8Array>;
+    saveAsync(): Promise<Uint8Array>;
+    private buildPackage;
+    private buildPackageFiles;
+    /**
+     * Leave out the chart parts the document no longer references.
+     *
+     * Deleting a chart splices its w:drawing out of the story, but the chart
+     * part, its rels part, its embedded workbook, the document relationship, and
+     * the two [Content_Types].xml overrides all stay. An agent that inserts a
+     * chart, deletes it, and inserts a replacement therefore saves TWO chart
+     * parts for the one chart the document shows.
+     *
+     * The release happens here, at save time, rather than when the drawing goes,
+     * because undo restores the drawing XML — r:id and all — from a snapshot
+     * that models package parts but no relationship state. Dropping the
+     * relationship early would make undo produce a chart pointing at nothing.
+     * The live tree keeps everything; only the written bytes lose the orphans,
+     * and the saveJournal puts back the two trees this touches.
+     *
+     * Relationship ids are scoped to the part that owns the rels file, so the
+     * document body is the only place that can reference these ids, and reading
+     * it is a complete check. Headers, footers, and notes carry their own rels.
+     */
+    private dropOrphanChartParts;
+    /** Fresh unique docPr id for inserted drawings. Seeded once past the
+     * highest id already present in any editable root (floor 1000, matching
+     * the historical seed for documents with no drawings) so a document that
+     * already carries drawings never gets a colliding id. */
+    nextDrawingId(): number;
+    /** Next unused revision id (w:id on w:ins/w:del). Seeded once past the
+     * highest id already present in any editable root so a document that
+     * already has tracked changes never collides. */
+    private revIdCounter;
+    nextRevisionId(): number;
+    /**
+     * Add image bytes as a new media part + relationship (+ content-type
+     * default). Returns the relationship id for use in a w:drawing.
+     */
+    private ensureRelsRoot;
+    /** Register an external hyperlink relationship and return its rId. */
+    /**
+     * Copy the part that `source`'s main-document relationship `relId` points
+     * at into this package, with every part it references in turn (a chart's
+     * embedded workbook, SmartArt's layout, style and colour parts) and their
+     * content types, and add a relationship to it. Returns the new
+     * relationship id, or null when the source has no such internal part.
+     *
+     * compareDocuments needs this for struck content: a removed picture keeps
+     * its w:drawing, and without its image part the result's reject-all
+     * brought the picture back as an empty frame.
+     */
+    adoptRelFrom(source: DocxDocument$1, relId: string, scope?: {
+        from?: string | null;
+        into?: string | null;
+    }): string | null;
+    /** Give a part copied from `source` the content type it had there. */
+    private adoptContentType;
+    addHyperlinkRel(url: string, ownerPart?: string | null): string;
+    /** Retarget an existing external relationship (hyperlink href edit). */
+    setRelTarget(relId: string, url: string): boolean;
+    /** The relationships owned by `part` (a header or footer part), or by the
+     * document part when null; a header or footer gets a rels root on demand. */
+    private relsOwnerOf;
+    /** The relationships of `part` (a header or footer), or of the document part. */
+    relationshipsOf(part?: string | null): Relationships;
+    /** The relationships of the part that holds `source`: a header or footer
+     * part when the element is inside one, else the document part. */
+    private imageRelsOwner;
+    /** Add an image relationship pointing at `part`, in the relationships of
+     * whichever part holds `source`. */
+    private addImageRel;
+    /**
+     * Point a SECOND part at an image part this document already has.
+     *
+     * Word's picture watermark is ONE media part that every header part
+     * references. Registering the image again per header would put a full copy
+     * of the bytes in the package for each one — three headers, three copies of
+     * the same logo — and give the media-install path three pending parts to
+     * fill from one upload.
+     */
+    linkImageResource(part: string, source: XmlElement): string;
+    private addImageResourceAt;
+    addImageResource(bytes: Uint8Array, ext: string): string;
+    /** Add a GLB model part and its Office 2019 model3d relationship. */
+    addModel3DResource(bytes: Uint8Array): {
+        relId: string;
+        part: string;
+    };
+    /** Add an OLE package part used by a Word w:object. */
+    addEmbeddedObjectResource(bytes: Uint8Array): {
+        relId: string;
+        part: string;
+    };
+    /** Add a DOCX package embedded as an activatable Word.Document.12 object. */
+    addEmbeddedWordDocumentResource(bytes: Uint8Array): {
+        relId: string;
+        part: string;
+    };
+    /** Add a native ChartML part and its embedded editable workbook. */
+    addChartResource(chartXml: string, workbook: Uint8Array): {
+        relId: string;
+        part: string;
+    };
+    /** Add the SmartArt data/layout/style/color parts and its cached diagram drawing. */
+    addSmartArtResources(layoutXml: string, styleXml: string, colorsXml: string, drawingXml: string, dataXml: (drawingRelId: string) => string): {
+        dataRelId: string;
+        layoutRelId: string;
+        styleRelId: string;
+        colorsRelId: string;
+        drawingRelId: string;
+    };
+    /** A document from .docx bytes, including Strict Open XML packages. */
+    static load(data: ArrayBuffer | Uint8Array): DocxDocument$1;
+    /** A document over parts already unzipped (stream/body.ts's shell). */
+    /**
+     * A document over an already-unzipped entry map. With `headerFooterBlocks`
+     * false, `headers` and `footers` stay empty: their XML is still read,
+     * compared and saved, but no block models are built from it (about 1 KB a
+     * paragraph), for a caller that compares the document and never lays it out
+     * (compare-cli).
+     */
+    static fromFiles(files: Record<string, Uint8Array>, options?: FromFilesOptions): DocxDocument$1;
+    /** The context the body's blocks are parsed with, for a caller that keeps
+     * the body outside the document (stream/body.ts). Its REF bookmark capture
+     * starts empty; the caller decides whether `refBookmarks` reads from it. */
+    bodyParseContext(): DocParseContext;
+    media(part: string): Uint8Array | undefined;
+    /**
+     * Pending-media registry (plan doc 05 change 1 / doc 16 §6): parts whose
+     * XML registration (rels + content-type + extent geometry) exists but
+     * whose BYTES have not arrived yet — the out-of-band media model. Layout
+     * needs no bytes (extents live in the XML), so a doc with pending parts
+     * lays out pixel-identically; the renderer shows a placeholder until
+     * `installMedia`. Keyed by part name; the value is the doc-16 §5.3
+     * metadata (declared sha + optional E2EE iv/epoch for re-supply).
+     */
+    readonly pendingMedia: Map<string, {
+        sha: string;
+        iv?: string;
+        genesisId?: string;
+    }>;
+    /** DISPLAY-ONLY transfer state for a pending part (doc 16 §5.2 step 4), so
+     * the skeleton can say "fetching" versus "nobody online has this yet".
+     * Written by the media transfer layer, read by the renderer; never part of
+     * the document's identity and never serialized. */
+    readonly mediaTransferState: Map<string, "unavailable" | "fetching" | "waiting">;
+    /** Per-part media metadata that PERSISTS after install (doc 16 §5.3):
+     * holder duty needs the sha (and E2EE iv/epoch) of READY parts to answer
+     * re-supply requests; pendingMedia above only tracks not-yet-arrived. */
+    readonly mediaMeta: Map<string, {
+        sha: string;
+        iv?: string;
+        genesisId?: string;
+    }>;
+    /** "ready" = bytes present; "pending" = registered, bytes absent (doc 05).
+     * Unregistered parts report "pending" too — a rel pointing at a missing
+     * zip entry after a save/parse round-trip IS the pending state (a hole is
+     * detectable, never corrupt — doc 16 §6 round-trip rule). */
+    mediaStatus(part: string): "ready" | "pending";
+    /**
+     * Register an image part + relationship WITHOUT bytes (doc 16 §2: the
+     * intent carries the sha; bytes travel out of band). Same deterministic
+     * naming/rId scan as addImageResource so every replica applying the same
+     * canonical intent derives identical registration.
+     */
+    registerPendingImage(sha: string, ext: string, meta?: {
+        iv?: string;
+        genesisId?: string;
+    }, source?: XmlElement): string;
+    /** As registerPendingImage, and also names the part it made — what a second
+     * part needs to reach the same image through linkImageResource. */
+    registerPendingImagePart(sha: string, ext: string, meta?: {
+        iv?: string;
+        genesisId?: string;
+    }, source?: XmlElement): {
+        relId: string;
+        part: string;
+    };
+    /** Install fetched bytes into a pending part (doc 05). The caller has
+     * ALREADY verified the sha against the intent's declaration (the
+     * reservation is the hash commitment — doc 16 §1.1); this installs and
+     * clears the pending record. Returns false for unknown parts. */
+    installMedia(part: string, bytes: Uint8Array): boolean;
+    /** Effective paragraph properties: docDefaults → table style → style chain → direct. */
+    effectiveParaProps(para: Paragraph): ParaProps;
+    /**
+     * Run props contributed by the enclosing table style's conditional
+     * w:tblStylePr blocks for this paragraph's cell (undefined when the
+     * paragraph isn't in a styled table cell or nothing applies).
+     */
+    private tableCondRPr;
+    /** Effective run properties for a run inside a paragraph. */
+    effectiveRunProps(para: Paragraph, runProps: RunProps): RunProps;
+    numberingLevel(numId: number, ilvl: number): NumberingLevel | undefined;
+    numberingInstance(numId: number): NumInstance | undefined;
+    private findDocumentPart;
+    private readXmlOptional;
+    /** A part Word prints (the document, a header or footer, the notes, the
+     * comments), refused when it holds a w:altChunk anywhere. */
+    private readPrintedXml;
+}
+
+/** Word documents, including binary .doc and the oldest Word formats. */
+declare class DocxDocument extends DocxDocument$1 {
+    private constructor();
+    static load(data: ArrayBuffer | Uint8Array): DocxDocument;
+    static fromFiles(files: Record<string, Uint8Array>, options?: FromFilesOptions): DocxDocument;
+    clone(): DocxDocument;
+}
+
+/** Maps a rendered text item back to its source XML for editing. */
+interface TextSource {
+    run: Run;
+    /** Source w:t; null when the text is synthetic (fields, symbols). */
+    t: XmlElement | null;
+    /** Char offset of this item's first character within t's text. */
+    offset: number;
+}
+/**
+ * Layout output: pages of absolutely positioned primitives (px, page-relative).
+ * The renderer maps these 1:1 to DOM/canvas/SVG — no further layout happens
+ * downstream, which is what guarantees pagination fidelity.
+ */
+interface FontSpec {
+    family: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+    /** Pair kerning is active because the run met its w:kern size threshold. */
+    kerning?: boolean;
+    /** The run's complex-script language (w:lang w:bidi, BCP 47), for the
+     * shaper's language-specific forms; absent when the run names none. */
+    lang?: string;
+    /** Optional PAINT-only family tried before `family` in the CSS stack, without
+     * affecting metrics or width lookups (keyed by `family`). Used for CJK: the
+     * line-pitch profile stays keyed by the macOS substitute face while the real
+     * Windows glyphs (MS Mincho, Microsoft JhengHei, …) paint when available. */
+    paintFamily?: string;
+    /** PAINT-only vertical nudge (CSS px, positive = down) applied to the glyphs
+     * without touching layout metrics or advances. Used when a substitute face
+     * (Latha for Word's Tamil Vijaya) sits on a different baseline than the face
+     * Word rasterized; the shift lands the glyphs on Word's baseline. */
+    paintDY?: number;
+}
+interface PathItem {
+    kind: "path";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** SVG path data in a `viewW x viewH` coordinate space. */
+    d: string;
+    viewW: number;
+    viewH: number;
+    fill?: string;
+    stroke?: {
+        color: string;
+        width: number;
+        opacity?: number;
+    };
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    /** Paint under / over the body text (anchored-shape layering). */
+    behind?: boolean;
+    front?: boolean;
+    z?: number;
+}
+interface TextItem {
+    kind: "text";
+    x: number;
+    /** Baseline y. */
+    baseline: number;
+    width: number;
+    text: string;
+    props: RunProps;
+    font: FontSpec;
+    /** Footnote/endnote id referenced by this run (registration happens when
+     * the item lands on a real page - split table rows carry it across). */
+    noteId?: number;
+    /** Vertical stretch for tall delimiter glyphs (Word's glyph variants). */
+    mathScaleY?: number;
+    /** Horizontal stretch for wide brace glyphs (Word's over/under brace
+     * variants), applied about the glyph box's horizontal center. */
+    mathScaleX?: number;
+    /** Stretch anchor above the baseline, px. */
+    mathScaleAnchor?: number;
+    /** Line box for selection/highlight backgrounds. */
+    lineTop: number;
+    lineHeight: number;
+    /** Exact glyph box for baseline-shifted runs (superscript/subscript):
+     * the renderer anchors these instead of bottoming on the line box. */
+    glyphTop?: number;
+    glyphBoxH?: number;
+    /** Small-caps reduced segment: the base run font that must supply the
+     * strut so the painted baseline matches neighboring full-size spans (the
+     * renderer sizes the outer span with this font and shrinks the text via
+     * a baseline-aligned inner span). */
+    strutFont?: FontSpec;
+    /** PAGEREF bookmark name: the final pass rewrites this item's text with
+     * the bookmark's page number (Word recomputes PAGEREF on open; the docx
+     * cached result is stale in real TOCs). */
+    pageRef?: string;
+    /** DOCX bookmarks that begin on this text item. */
+    bookmarks?: string[];
+    /** Source m:oMath element when this text is a piece of an equation. */
+    mathSrc?: XmlElement;
+    href?: string;
+    /** Present for editable text (absent on numbering labels etc.). */
+    src?: TextSource;
+    /** This line is one a fixed-size text box hides past its bottom edge (see
+     * LaidOutPage.hiddenText). It mounts unpainted so a caret can bind to it, so
+     * anything that draws from item geometry — selection, comment highlights —
+     * must skip it or it paints a block where there is no text. */
+    hidden?: true;
+    /** The box an exact-height table row clips this line to (page px): the
+     * line starts inside the row but crosses its bottom edge, and only the
+     * part inside the box is drawn, as Word draws it. */
+    clip?: {
+        top: number;
+        bottom: number;
+    };
+    /** The text is part of a tracked change, or its paragraph's format was
+     * changed: a printed markup page bars the line in the margin. */
+    changed?: true;
+    /** Printed markup: this empty item is the clear space after a tracked
+     * change that ends inside a word, where the change's bar goes. */
+    changeGap?: true;
+    /** Source drawing when this text belongs to an independently editable
+     * text-box story. */
+    textboxStory?: XmlElement;
+    /** Rotate about a point (px, relative to this item's top-left). */
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    /** Paint under the body text (behindDoc textbox content). */
+    behind?: boolean;
+    /** Paint over the body text (non-behindDoc anchored shape content: Word
+     * layers in-front shapes above the text layer). */
+    front?: boolean;
+    z?: number;
+    /** Paint-only alpha for decorative text such as DrawingML WordArt. */
+    opacity?: number;
+    /** Right-to-left run: renderer sets direction:rtl so the browser shapes and
+     * orders the (Arabic/Hebrew) glyphs within the span box. */
+    rtl?: boolean;
+    /** Ordinal of the source paragraph within its cell/frame. Set only for
+     * widow-controlled paragraphs; row splitting uses it to scope Word's
+     * widow/orphan rules to the paragraph straddling the cut. */
+    paraSeq?: number;
+    /** Editor-only: maximum caret x for this item — a trailing hanging space
+     * confined to its table cell pins the caret at the cell's content edge
+     * (Word behavior) while the span keeps its true hanging layout x. */
+    caretClampX?: number;
+    /** A trailing space hung past the line's end: it draws no underline or strike. */
+    hanging?: boolean;
+}
+interface RectItem {
+    kind: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill: string;
+    /** Semantic paint provenance used by render-layer comparison. */
+    role?: "table-fill";
+    /** Rotate about a point (px, relative to this item's top-left). */
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    behind?: boolean;
+    /** Paint over the body text (non-behindDoc anchored shape fill). */
+    front?: boolean;
+    z?: number;
+}
+interface LineEdgeItem {
+    kind: "edge";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    border: Border;
+    /** PDF paint extensions along the rule; layout keeps the original endpoints. */
+    extendStart?: number;
+    extendEnd?: number;
+    /** The box's shadow strip, and its extension past the bottom-right corner. */
+    shadowSide?: "right" | "bottom";
+    shadowEnd?: number;
+    /** Semantic paint provenance used by render-layer comparison. */
+    role?: "table-rule";
+    /** Rotate about a point (px, relative to this item's top-left). */
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    /** Paint over the body text (non-behindDoc anchored shape border). */
+    front?: boolean;
+    /** Paint below the body text (behindDoc anchored shape border). */
+    behind?: boolean;
+    z?: number;
+}
+interface ImageItem {
+    kind: "image";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Package part path; renderer resolves bytes via DocxDocument.media(). */
+    part: string;
+    /** a:srcRect crop (fractions) and a:xfrm rotation (degrees). */
+    crop?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    rotation?: number;
+    /** Whole-group rotation about an external origin. */
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    /** Picture-watermark "washout" (VML v:imagedata gain/blacklevel, 0..1
+     * fractions). Per-channel linear recolor, measured against Word's PDF of
+     * probe2-picture-watermark (gain 0.3, blacklevel 0.35: source 32 -> 215,
+     * 74 -> 227, 135 -> 246, 210 -> clamped 255):
+     *   out = in * gain + 255 * (blacklevel * (1 + gain) + (1 - gain) / 2)  */
+    washout?: {
+        gain: number;
+        blacklevel: number;
+    };
+    /** a:ln picture outline, drawn just outside the image (Word hairline). */
+    border?: {
+        color: string;
+        width: number;
+    };
+    /** behindDoc: paint under the text layer. */
+    behind?: boolean;
+    /** wrapNone + !behindDoc ("in front of text"): paint ABOVE the text layer
+     * (Word's z-order; without this, later-emitted text spans cover the image
+     * and it neither shows in front nor receives clicks/drags). */
+    front?: boolean;
+    z?: number;
+    /** Source w:drawing element (for interactive resize/move). */
+    src?: XmlElement;
+    model3D?: Model3DReference;
+    webVideo?: WebVideoReference;
+    embeddedObject?: EmbeddedObjectReference;
+    /** Printed markup: the tracked changes the picture's run is part of, and
+     * the run's revision color, which frames the picture (and strikes a
+     * deleted one). A balloon and a change bar go with them, as for text. */
+    changes?: Revision[];
+    changeColor?: string;
+}
+interface ChartItem {
+    kind: "chart";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    data: ChartData;
+}
+/** bodyPr autofit mode: how a shape reconciles its text with its box.
+ * "resizeShape" is a:spAutoFit (grow the box), "shrinkText" is a:normAutofit
+ * (scale the text down), "none" is a:noAutofit or no bodyPr autofit at all. */
+type ShapeAutofit = "none" | "resizeShape" | "shrinkText";
+/** What a text-bearing shape's laid-out text measured, beside the frame that
+ * holds it. The layout already measures the text to place it; recording the
+ * measurement here is what lets an agent see whether the text fits without
+ * re-measuring anything. */
+interface DrawingTextFit {
+    /** Widest laid line, px (the text extent, not the box). It can exceed the
+     * box's inset width by a trailing space or an unbreakable token. */
+    textW: number;
+    /** Full laid text height, px. */
+    textH: number;
+    /** The text is taller than the box's insets leave room for. Overflow is a
+     * vertical question: the text is wrapped to the box width by construction,
+     * and a token too wide to wrap spends its excess on extra LINES. */
+    overflow: boolean;
+    /** Lines the box hides because they fall past its bottom. */
+    clippedLines: number;
+    autofit: ShapeAutofit;
+}
+/** Interactive resize zone over a table boundary (column or row). */
+interface DrawingHitItem {
+    kind: "drawingHit";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Source w:drawing element (select/move the whole drawing). */
+    src: XmlElement;
+    /** Anchored drawings drag by offset; inline ones re-anchor into text. */
+    anchored: boolean;
+    /** Freehand stroke that may be removed with the Draw ribbon's eraser. */
+    ink?: boolean;
+    /** Native SmartArt diagram selection target. */
+    smartArt?: boolean;
+    /** Node hit boxes inside the SmartArt drawing, relative to this item. */
+    smartArtNodes?: Array<{
+        index: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    chartData?: ChartData;
+    smartArtData?: SmartArtData;
+    /** A shape fill hit that sits UNDER the shape's own text spans (same z): a
+     * click on bare fill selects or drags the shape, while clicks on its text
+     * glyphs still reach the text editor. */
+    belowText?: boolean;
+    /** Keep a behindDoc drawing target under the body text. */
+    behind?: boolean;
+    /** The drawing owns an independently editable text-box story. */
+    textboxStory?: boolean;
+    /** Measured text extent for a text-bearing shape (agent fit inspection).
+     * Absent on drawings that flow no text: pictures, lines, charts, WordArt. */
+    textFit?: DrawingTextFit;
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    z?: number;
+}
+interface GripItem {
+    kind: "grip";
+    /** "col": vertical zone at x spanning y1..y2. "row": horizontal zone at y1
+     * spanning x..x2. "move": table bounds x..x2, y1..y2. */
+    axis: "col" | "row" | "move";
+    x: number;
+    y1: number;
+    y2: number;
+    /** Right edge for row grips. */
+    x2?: number;
+    /** Source w:tbl element. */
+    tbl: XmlElement;
+    /** col: boundary 1..n (n = right edge). row: row index above the boundary. */
+    boundary: number;
+    /** Laid-out height of the row above (row grips), px. */
+    rowHeightPx?: number;
+    /** Rendered column widths px (col grips) — resize works in this space. */
+    renderedWidths?: number[];
+}
+/** WordArt/watermark text scaled to fill a box, rotated about its center. */
+interface WordArtItem {
+    kind: "wordart";
+    /** Box top-left, px. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontFamily: string;
+    bold?: boolean;
+    italic?: boolean;
+    fill: string;
+    opacity: number;
+    /** Clockwise degrees. */
+    rotation: number;
+    behind?: boolean;
+    /** Source v:textpath font-size (px). */
+    fontSize?: number;
+    /** Malformed shapetype guide path: Word collapses the fitted glyph outlines
+     * into a thin vertical band. */
+    noFit?: boolean;
+    /** Source VML shape element (v:shape / v:rect), for interactive select/edit. */
+    src?: XmlElement;
+}
+/** DrawingML a:prstTxWarp text: the shape's single text line bent onto a
+ * preset envelope (arch/wave/chevron/circle-pour), filling the shape box. */
+interface WarpTextItem {
+    kind: "warptext";
+    /** Shape box top-left, px. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontFamily: string;
+    /** Run font size px (the text's natural size; presets that don't fill the
+     * box — textArchUp — ride the text at this size). */
+    fontSize: number;
+    bold?: boolean;
+    italic?: boolean;
+    /** CSS text color. */
+    fill: string;
+    /** WordArt glyph alpha, 0..1. */
+    opacity?: number;
+    /** w14:textOutline glyph stroke. */
+    outline?: {
+        color: string;
+        width: number;
+    };
+    /** w14:shadow / w:shadow offset glyph shadow. */
+    shadow?: boolean;
+    /** Preset name (textArchUp, textWave1, textChevron, textCirclePour, …). */
+    warp: string;
+    rotate?: {
+        deg: number;
+        ox: number;
+        oy: number;
+    };
+    behind?: boolean;
+    front?: boolean;
+    z?: number;
+}
+type PageItem = TextItem | PathItem | RectItem | LineEdgeItem | ImageItem | ChartItem | DrawingHitItem | GripItem | WordArtItem | WarpTextItem;
+interface LaidOutPage {
+    width: number;
+    height: number;
+    /** 1-based physical index. */
+    index: number;
+    /** Display page number after pgNumType.start is applied. */
+    number: number;
+    items: PageItem[];
+    /** Body box (for header/footer editing chrome). */
+    bodyTop: number;
+    bodyBottom: number;
+    /** Items from this index on belong to the header/footer parts. */
+    hfStart: number;
+    /** Column geometry for editor hit-testing. A page can contain more than one
+     * band when a continuous section changes the column layout mid-page. */
+    columnBands: Array<{
+        top: number;
+        colXs: number[];
+        colWidths: number[];
+    }>;
+    /** Lines a fixed-size text box (a:noAutofit) hides past its bottom edge.
+     * Held apart from `items` so nothing that paints, measures, or reads the
+     * page picks them up: they exist only so a caret that lands in the hidden
+     * part of a text-box story still has a place to be. */
+    hiddenText?: TextItem[];
+}
+/** Internal page-model window used by the DOM virtualizer. */
+interface LayoutWindow {
+    /** Ensure that each requested page has a complete positioned item model. */
+    materialize(pageIndexes: Iterable<number>): void;
+    /** Release positioned items outside the requested page window. */
+    releaseExcept(pageIndexes: Iterable<number>): void;
+    /** Return the pages whose positioned items are retained. */
+    retainedPages(): Set<number>;
+}
+interface LayoutFontSample {
+    font: FontSpec;
+    text: string;
+}
+interface LayoutResult {
+    pages: LaidOutPage[];
+    totalPages: number;
+    /** Opaque incremental-reuse state (engine-internal); pass a previous result
+     * back as LayoutOptions.prev to enable incremental relayout. Not part of the
+     * rendered output and ignored by the equivalence harness. */
+    _incr?: unknown;
+    /** Internal marker: unchanged pages in this result retain exact object
+     * identity from the previous layout, so the DOM diff can use identity
+     * instead of structurally walking a dense changed page. */
+    _incremental?: boolean;
+    /** Exclusive global page index through which an incremental render may run
+     * pageEq before the page containing the exact dirty text source. */
+    _incrementalStructuralPrefixEnd?: number;
+    /** Opaque page state used to refresh headers/footers without repaginating
+     * the body when their measured geometry is unchanged. */
+    _hf?: unknown;
+    /** Internal positioned-model window. */
+    _window?: LayoutWindow;
+    /** Font samples collected before offscreen page items were released. */
+    _fontSamples?: LayoutFontSample[];
+    /** True when any page contains a 3D model item. */
+    _hasModel3D?: boolean;
+}
+
+interface FontMetrics {
+    /** px above baseline (raw font ascent - anchors CSS glyph boxes). */
+    ascent: number;
+    /** px below baseline, raw (positive - anchors CSS glyph boxes). */
+    descent: number;
+    /** Natural single-spaced line height px (what Word calls single spacing). */
+    lineHeight: number;
+    /** Word's below-baseline share of lineHeight (quantized); use for
+     * baseline placement. Falls back to `descent` when absent. */
+    lineDescent?: number;
+}
+interface TextMeasurer {
+    width(text: string, font: FontSpec, letterSpacing?: number): number;
+    /** Whether each suffix of this text has nondecreasing prefix widths.
+     * Lets emergency wrapping search near the line end without measuring the
+     * entire remaining token on every line. */
+    isPrefixWidthMonotone?(text: string, font: FontSpec, letterSpacing?: number): boolean;
+    metrics(font: FontSpec): FontMetrics;
+    /** The browser's own font box (fontBoundingBoxAscent/Descent) for the
+     * resolved first face of this font's CSS stack, when the host can know it.
+     * Used to anchor paint-routed CJK spans: the DOM renderer centers glyphs
+     * by the browser strut, which differs from the engine's calibrated line
+     * profile (Hiragino/PingFang) whenever the real Windows face paints. */
+    paintBox?(font: FontSpec): {
+        ascent: number;
+        descent: number;
+    } | undefined;
+    /** Ink extents (actualBoundingBox*) of `text` in the RESOLVED paint face,
+     * px above/below the baseline. The radical join needs the √ glyph's real
+     * ink — which face paints it (real Cambria Math vs the STIX substitute)
+     * changes the extents, so a baked table can't cover both. */
+    inkBox?(text: string, font: FontSpec): {
+        ascent: number;
+        descent: number;
+    } | undefined;
+}
+
+/** One mail-merge data record: column name → this record's value. The host
+ * parses the data file and hands over plain strings; the engine never learns a
+ * path, a connection string or a query. */
+type MergeRecord = Readonly<Record<string, string>>;
+interface LayoutOptions {
+    measurer?: TextMeasurer;
+    /** Retain positioned items only for a viewport-sized page window. */
+    windowModel?: boolean;
+    /** Mail-merge PREVIEW: the active record's column values, substituted into
+     * MERGEFIELD fields as they are painted. Nothing is written to the document —
+     * see FieldContext.mergeField. Absent renders the «Name» placeholders. */
+    mergeRecord?: MergeRecord;
+    /** Previous layout result (from an earlier layoutDocument call on the same
+     * document). Enables incremental relayout: pages whose input blocks and
+     * lead-in state are unchanged are reused instead of re-laid. The engine falls
+     * back to a full layout whenever it cannot prove reuse is byte-identical. */
+    prev?: LayoutResult;
+    /** The top-level block XML element (w:p / w:tbl) the editor mutated IN PLACE
+     * since `prev` — the paragraph the caret sits in for a single-character
+     * type/delete. Lets the incremental scan skip re-hashing every block: it
+     * re-hashes only the hinted block and its two neighbours and reuses prev's
+     * per-block signatures for the rest. Purely an optimisation — the fast path
+     * is gated on block identity/count and neighbour-signature checks, so a stale
+     * or wrong hint falls through to the full block scan. */
+    dirtyHint?: XmlElement;
+    /** Exact retained text element changed by a local edit. Used only to bound
+     * structural page comparison before the first actually dirty page. */
+    dirtySource?: XmlElement;
+}
+interface AsyncLayoutOptions extends LayoutOptions {
+    /** Cancels a superseded background layout before its result is painted. */
+    signal?: AbortSignal;
+    /** Maximum main-thread time spent between event-loop yields. */
+    sliceMs?: number;
+}
+declare function layoutDocument(doc: DocxDocument, options?: LayoutOptions): LayoutResult;
+/** Full layout that yields between top-level blocks for large interactive
+ * documents. The completed result is identical to layoutDocument; callers
+ * should paint it atomically and discard it when the signal is aborted. */
+declare function layoutDocumentAsync(doc: DocxDocument, options?: AsyncLayoutOptions): Promise<LayoutResult>;
+
+interface RenderOptions {
+    /** Zoom factor (1 = 100%). */
+    zoom?: number;
+    /** Gap between pages, px. */
+    pageGap?: number;
+    /** Page drop shadow / chrome. */
+    pageShadow?: boolean;
+    /** Materialize interactive affordances (table resize grips). */
+    interactive?: boolean;
+    /** Keep only nearby page contents mounted. Page shells always remain so
+     * scroll geometry is unchanged. Intended for long interactive documents. */
+    virtualize?: boolean;
+    /** Called after the mounted page window changes so editor chrome can be
+     * restored on newly-mounted pages. */
+    onViewportChange?: () => void;
+    /** Show review comments (highlight + margin balloons). Default true. */
+    comments?: boolean;
+    /** Called when the user deletes a comment from its balloon. The balloon
+     * shows a delete button only when this is provided. */
+    onDeleteComment?: (id: string) => void;
+    /** Called when the user submits a reply from a balloon's reply box. The
+     * reply box only renders when this is provided. */
+    onReplyComment?: (id: string, text: string) => void;
+    /** Called when the user resolves (true) or reopens (false) a thread from
+     * its balloon. The button only renders when this is provided. */
+    onResolveComment?: (id: string, resolved: boolean) => void;
+    /** Called when the user commits an in-balloon edit of a comment's text.
+     * Offered only on comments whose author matches `commentAuthor`. */
+    onEditComment?: (id: string, text: string) => void;
+    /** The local user's comment author name — gates the edit affordance to
+     * their own comments (Word's edit-my-comment rule). */
+    commentAuthor?: string;
+}
+interface TextBinding {
+    el: HTMLElement;
+    item: TextItem;
+}
+interface GripBinding {
+    el: HTMLElement;
+    item: GripItem;
+}
+interface ImageBinding {
+    el: HTMLElement;
+    item: ImageItem;
+}
+interface DrawingBinding {
+    el: HTMLElement;
+    item: DrawingHitItem;
+}
+interface WordArtBinding {
+    el: HTMLElement;
+    item: WordArtItem;
+}
+interface RenderHandle {
+    /** Root element containing all pages. */
+    root: HTMLElement;
+    /** Rendered text elements in paint order, for selection mapping. */
+    bindings: TextBinding[];
+    /** Mounted text bindings indexed by their retained source w:t element. */
+    bindingsByText: Map<XmlElement, TextBinding[]>;
+    /** Table resize grips (only when options.interactive). */
+    grips: GripBinding[];
+    /** Rendered images, for interactive select/resize/move. */
+    images: ImageBinding[];
+    /** Transparent hit targets over vector drawings/icons (select/move). */
+    drawings: DrawingBinding[];
+    /** WordArt / text watermarks, for interactive select/edit. */
+    wordarts: WordArtBinding[];
+    /** Revoke object URLs etc. */
+    destroy: () => void;
+    /** Temporarily mount every page, returning a function that restores the
+     * viewport window. Used by the synchronous print-clone path. */
+    materializeAll?: () => () => void;
+    /** Recompute the mounted page window after an external scroll/resize. */
+    updateViewport?: () => void;
+    /** Per-page render records, retained so the next render can reuse the DOM of
+     * pages whose layout is unchanged (see renderToDom's `prev` parameter). */
+    _pages?: PageRender[];
+    /** Whether this render drew the comments overlay. Comment highlights live
+     * INSIDE page surfaces, so the next render must sweep them out of any page
+     * DOM it adopts before re-running the overlay. */
+    _hadComments?: boolean;
+    /** Zoom this render painted at — adoption is only valid at the same zoom. */
+    _zoom?: number;
+    /** Whether this handle keeps only a viewport-sized page window mounted. */
+    _virtualized?: boolean;
+    /** Parsed-model generation whose source bindings this handle owns. */
+    _modelVersion?: number;
+    /** Remove viewport listeners before this handle is replaced. */
+    _stopVirtualizer?: () => void;
+}
+/** One page's DOM element plus the editor bindings it owns and the object URLs
+ * it created. Retained on the handle so an incremental re-render can adopt an
+ * unchanged page wholesale instead of tearing it down and rebuilding it. */
+interface PageRender {
+    el: HTMLElement;
+    page: LaidOutPage;
+    bindings: TextBinding[];
+    grips: GripBinding[];
+    images: ImageBinding[];
+    drawings: DrawingBinding[];
+    wordarts: WordArtBinding[];
+    urls: string[];
+    mounted: boolean;
+}
+declare function renderToDom(doc: DocxDocument, layout: LayoutResult, container: HTMLElement, options?: RenderOptions, prev?: RenderHandle): RenderHandle;
+/**
+ * Print the rendered pages (browser print -> paper or PDF): clones the page
+ * DOM into a hidden same-origin iframe sized to the document's page, strips
+ * screen chrome (shadows, gaps), and invokes the print dialog.
+ */
+declare function printPages(root: HTMLElement, pageWidthPx: number, pageHeightPx: number): void;
+
+export { type ChartData as C, DocxDocument as D, type EncodedCaret as E, type MergeRecord as M, type RunProps as R, StableIds as S, type XmlElement as X, type Run as a, type SmartArtData as b, DocxDocument$1 as c, layoutDocumentAsync as d, layoutDocument as l, printPages as p, renderToDom as r };