wordinweb 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1985 @@
+import * as react from 'react';
+
+/**
+ * Minimal, fast XML parser producing a lightweight element tree.
+ *
+ * OOXML parts are machine-generated, namespace-prefixed, well-formed XML with
+ * no DTDs. This parser handles exactly that subset: elements, attributes,
+ * text, CDATA, comments, processing instructions, and the built-in + numeric
+ * character entities. Namespace prefixes are kept verbatim (`w:p`), and
+ * lookups match on either the full name or the local name, which is robust
+ * for every mainstream producer (Word, LibreOffice, Google Docs export).
+ */
+interface XmlElement {
+    name: string;
+    attrs: Record<string, string>;
+    children: XmlElement[];
+    /** Concatenated character data directly inside this element. */
+    text: string;
+}
+
+/**
+ * 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" | "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;
+}
+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;
+    /** 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;
+    /** w:emboss / w:imprint — Word triple-draws offset copies. */
+    emboss?: boolean;
+    imprint?: boolean;
+    vanish?: boolean;
+    /** Character style id (w:rStyle). */
+    styleId?: string;
+    lang?: 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;
+}
+/** 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;
+} | {
+    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[];
+};
+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;
+    /** 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;
+    /** 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;
+}
+/** 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;
+    hRel: AnchorRel;
+    vRel: AnchorRel;
+}
+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";
+    /** 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 this outline (in a viewW x viewH space
+     * scaled to the shape box) instead of a rectangle. */
+    geom?: {
+        d: string;
+        viewW: number;
+        viewH: number;
+    };
+    /** 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;
+    /** 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;
+    /** 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 v:textpath font-size (px). Only used when the text is NOT fit to the
+     * shape (see noFit). */
+    fontSize?: number;
+    /** The referenced v:shapetype has a malformed text-guide path (missing
+     * coordinates), so Word cannot compute the fitshape scale and falls back to
+     * drawing the string at its nominal font-size — a near-invisible mark rather
+     * than a box-filling watermark. Render at fontSize, unstretched, to match. */
+    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;
+    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";
+    behind?: boolean;
+    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;
+}
+type Shape = ShapeLine | ShapeTextbox | ShapeImage | ShapeArt | ShapeWordArt;
+/**
+ * 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;
+}
+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[];
+    /** 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[];
+}
+/** 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";
+}
+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;
+    };
+}
+/**
+ * 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;
+}
+/** 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;
+interface Run {
+    type: "run";
+    props: RunProps;
+    content: RunContent[];
+    /** Source w:r element. */
+    src?: XmlElement;
+    /** Element whose children array contains src (w:p, w:hyperlink, …). */
+    srcParent?: XmlElement;
+}
+interface Hyperlink {
+    type: "hyperlink";
+    href?: string;
+    anchor?: string;
+    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;
+    /** Source w:p element. */
+    src?: XmlElement;
+}
+interface TableCellProps {
+    /** Preferred width px (from tcW when dxa). */
+    width?: number;
+    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 {
+    /** 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. */
+    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: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;
+}
+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;
+    constructor(data: Uint8Array);
+    static from(data: ArrayBuffer | 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;
+}
+
+interface Relationship {
+    id: string;
+    type: string;
+    target: string;
+    external: boolean;
+}
+type Relationships = Map<string, Relationship>;
+
+/**
+ * A fully parsed .docx: sections of blocks, styles, numbering, theme, and
+ * header/footer parts, with helpers to resolve effective formatting.
+ */
+declare class DocxDocument {
+    /** 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;
+    get modelVersion(): number;
+    readonly pkg: Package;
+    readonly theme: Theme;
+    styles: Styles;
+    numbering: Numbering;
+    sections: Section[];
+    /** Header/footer parts keyed by relationship id from document.xml.rels. */
+    readonly headers: Map<string, HeaderFooter>;
+    readonly footers: Map<string, HeaderFooter>;
+    /** Note content by note id (render-only; sources stripped). */
+    readonly footnotes: Map<number, Block[]>;
+    readonly endnotes: Map<number, 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: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: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;
+    /** 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[];
+    /** 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;
+    /** 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;
+    /** 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";
+    private readonly relsPath;
+    private relsRoot;
+    private contentTypesRoot;
+    private nextDocPrId;
+    /** 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;
+    private constructor();
+    /**
+     * Re-derive the document model from the retained XML trees. Called after
+     * edit commands mutate the XML.
+     */
+    /** 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;
+    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 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;
+    /**
+     * 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.
+     */
+    ensureHfPart(kind: "header" | "footer"): XmlElement;
+    markFootnotesChanged(): void;
+    /** 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[]>;
+    /** The mutable XML roots (document body, header/footer parts, comments).
+     * The comments root is last so history snapshot indices stay stable. */
+    /** Flag the footnotes part dirty when `t` lives inside it, so save()
+     * re-serializes footnotes.xml. Called by the editor after a text edit; a
+     * no-op for body/header/footer targets. */
+    markDirtyIfFootnote(t: XmlElement): void;
+    editableRoots(): XmlElement[];
+    /**
+     * 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).
+     */
+    /** XML roots that can carry tracked changes: body, headers/footers, footnotes. */
+    revisionRoots(): XmlElement[];
+    findParentOf(target: XmlElement): XmlElement | undefined;
+    /**
+     * 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.
+     */
+    save(): Uint8Array;
+    /** Fresh unique docPr id for inserted drawings. */
+    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. */
+    addHyperlinkRel(url: string): string;
+    /** Retarget an existing external relationship (hyperlink href edit). */
+    setRelTarget(relId: string, url: string): boolean;
+    addImageResource(bytes: Uint8Array, ext: string): string;
+    static load(data: ArrayBuffer | Uint8Array): DocxDocument;
+    media(part: string): Uint8Array | undefined;
+    /** 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;
+}
+
+/** 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;
+    /** 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;
+    };
+    /** Paint under / over the body text (anchored-shape layering). */
+    behind?: boolean;
+    front?: boolean;
+}
+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;
+    /** 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;
+    /** 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;
+    /** 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;
+}
+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;
+}
+interface LineEdgeItem {
+    kind: "edge";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    border: Border;
+    /** 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;
+}
+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;
+    /** 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;
+    /** Source w:drawing element (for interactive resize/move). */
+    src?: XmlElement;
+}
+/** 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;
+    /** A shape fill hit that sits UNDER the shape's own text spans (same z): a
+     * click on bare fill selects the shape, but clicks on the text glyphs still
+     * reach the text for editing. Such hits select only (never drag-move). */
+    belowText?: boolean;
+}
+interface GripItem {
+    kind: "grip";
+    /** "col": vertical zone at x spanning y1..y2. "row": horizontal zone at y1
+     * spanning x..x2. */
+    axis: "col" | "row";
+    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;
+    /** v:textpath font-size (px), used only when noFit is set. */
+    fontSize?: number;
+    /** Malformed shapetype guide path: render at nominal fontSize, unstretched
+     * (Word can't fitshape, so it draws a near-invisible mark). */
+    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;
+    /** Preset name (textArchUp, textWave1, textChevron, textCirclePour, …). */
+    warp: string;
+    behind?: boolean;
+    front?: boolean;
+}
+type PageItem = TextItem | PathItem | RectItem | LineEdgeItem | ImageItem | 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;
+}
+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;
+    /** Opaque page state used to refresh headers/footers without repaginating
+     * the body when their measured geometry is unchanged. */
+    _hf?: unknown;
+}
+
+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;
+    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;
+}
+
+interface LayoutOptions {
+    measurer?: TextMeasurer;
+    /** 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-count parity and neighbour-signature checks, so a stale,
+     * structural, or wrong hint falls through to the full block scan. Absent for
+     * multi-block edits (paste, paragraph split/merge, undo/redo, structural ops),
+     * which take the full scan. */
+    dirtyHint?: XmlElement;
+}
+declare function layoutDocument(doc: DocxDocument, options?: LayoutOptions): 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;
+}
+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;
+
+interface RunFormatPatch {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    /** "#RRGGBB"; null removes the direct color. */
+    color?: string | null;
+    /** Word highlight name ("yellow", "cyan", …); null removes. */
+    highlight?: string | null;
+    /** Font size in points. */
+    fontSizePt?: number;
+    fontFamily?: string;
+    /** Superscript/subscript; null returns the run to the baseline. */
+    verticalAlign?: "superscript" | "subscript" | null;
+    /** Remove all direct character formatting (and character style). */
+    clear?: boolean;
+}
+interface SelectionFormat {
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    /** Common font size in points, if uniform. */
+    fontSizePt?: number;
+    color?: string;
+    highlight?: string;
+    fontFamily?: string;
+    verticalAlign?: "superscript" | "subscript";
+}
+
+type ParagraphAlignment = "left" | "center" | "right" | "justify";
+interface PageLayoutPatch {
+    /** Margins in inches. */
+    margins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /** Page size in inches (before orientation). */
+    size?: {
+        width: number;
+        height: number;
+    };
+    orientation?: "portrait" | "landscape";
+    /** Equal-width text columns (1 removes w:cols). */
+    columns?: number;
+    /** Box page border (null removes). sz in eighth-points, color hex. */
+    pageBorders?: {
+        sz?: number;
+        color?: string;
+        offsetFrom?: "text" | "page";
+    } | null;
+}
+
+/**
+ * Table manipulation: add/remove rows and columns relative to the cell
+ * containing the caret. Mutates source XML; callers checkpoint + relayout.
+ *
+ * v1 scope: column operations refuse tables using gridSpan (merged cells)
+ * rather than corrupt them.
+ */
+type TableOp = "rowAbove" | "rowBelow" | "deleteRow" | "colLeft" | "colRight" | "deleteCol" | "deleteTable" | "mergeRight" | "mergeDown" | "splitCell" | {
+    kind: "cellShading";
+    fill: string | null;
+} | {
+    kind: "cellVAlign";
+    v: "top" | "center" | "bottom";
+};
+
+interface LineNumberingPatch {
+    /** Turn margin line numbering on/off for the target section(s). */
+    enabled: boolean;
+    /** Number every Nth line (1/5/10). Default 1 when first enabled. */
+    countBy?: number;
+    /** When the count resets. Default newPage when first enabled. */
+    restart?: "continuous" | "newPage" | "newSection";
+    /** First line number. Default 1. */
+    start?: number;
+}
+
+interface MissingFont {
+    /** The face the document asked for (first name in the item's stack). */
+    family: string;
+    /** A short sample of text that will render in a substitute. */
+    sample: string;
+}
+
+/** Toolbar control groups a host can disable via the `features` prop. */
+type ToolbarFeature = "history" | "styles" | "font" | "size" | "format" | "color" | "highlight" | "alignment" | "indent" | "spacing" | "link" | "lists" | "table" | "image" | "comment" | "footnote" | "layout" | "download";
+declare function DocxToolbar({ api, onSave, features, className, style, }: {
+    api: DocxViewApi | null;
+    onSave?: (bytes: Uint8Array) => void;
+    /** Per-group overrides; every group defaults to enabled. */
+    features?: Partial<Record<ToolbarFeature, boolean>>;
+    /** Extra class on the toolbar root (e.g. a scope for CSS-variable overrides). */
+    className?: string;
+    /** Inline overrides merged onto the toolbar root; wins over the defaults. */
+    style?: React.CSSProperties;
+}): react.JSX.Element;
+
+interface DocxViewApi {
+    /** Apply character formatting to the current browser selection. */
+    applyFormat(patch: RunFormatPatch): void;
+    /** Create a review comment on the current selection. False if no selection. */
+    addComment(text: string): boolean;
+    /** Insert a footnote at the caret. False without a caret. */
+    addFootnote(text: string): boolean;
+    /** Insert a dynamic page-number field at the caret (body, header or footer). */
+    insertPageNumber(kind?: "page" | "pageOfTotal"): boolean;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Insert a rows×cols table at the caret's paragraph. */
+    insertTable(rows: number, cols: number): void;
+    /** Row/column/table operations on the table containing the caret. */
+    tableOp(op: TableOp): void;
+    /** Insert an image file at the caret (inline, natural size clamped to column). */
+    insertImage(file: Blob): Promise<void>;
+    /** Align the paragraph(s) under the caret or selection. */
+    setAlignment(align: ParagraphAlignment): void;
+    /** Apply a named paragraph style (null clears back to Normal). */
+    setParagraphStyle(styleId: string | null): void;
+    /** Toggle bulleted/numbered list on the paragraph(s) under the selection. */
+    toggleList(kind: "bullet" | "number"): void;
+    /** Current list kind at the caret ("bullet" | "number" | null). */
+    getListType(): "bullet" | "number" | null;
+    /** Link the selection to a URL; null removes the link at the caret. */
+    setLink(url: string | null): void;
+    /** URL of the hyperlink at the caret/selection, or null. */
+    getLinkAt(): string | null;
+    /** Step paragraph indent by half an inch (Word's indent buttons). */
+    adjustIndent(direction: 1 | -1): void;
+    /** Line spacing multiple and/or space before/after (points). */
+    setParagraphSpacing(patch: {
+        lineMultiple?: number;
+        beforePt?: number | null;
+        afterPt?: number | null;
+    }): void;
+    /** Remove direct character formatting from the selection. */
+    clearFormatting(): void;
+    /** Change the selection's case. */
+    changeCase(mode: "upper" | "lower" | "title"): void;
+    /** Find matches for a query; selects the first and returns the count. */
+    find(query: string, opts?: {
+        matchCase?: boolean;
+    }): number;
+    /** Select the next/previous match; returns 1-based index or 0. */
+    findStep(delta: 1 | -1): number;
+    /** Replace the current match; returns remaining match count. */
+    replaceCurrent(replacement: string): number;
+    /** Replace every match; returns how many were replaced. */
+    replaceAll(query: string, replacement: string): number;
+    /** Paragraph styles for the style menu (declared + Word built-ins). */
+    listParagraphStyles(): {
+        id: string;
+        name: string;
+    }[];
+    /** pStyle id of the caret paragraph (null = Normal). */
+    getParagraphStyleId(): string | null;
+    /** Change margins / page size / orientation (inches). */
+    setPageLayout(patch: PageLayoutPatch, scope?: "document" | "section"): void;
+    /** Insert a page/column break or a section break at the caret. */
+    insertBreak(kind: "page" | "column" | "sectionNextPage" | "sectionContinuous"): boolean;
+    /** Toggle/configure margin line numbers (Word's Layout > Line Numbers).
+     * scope "section" targets the caret's section; "document" every section. */
+    setLineNumbering(patch: LineNumberingPatch, scope?: "document" | "section"): void;
+    /** Current line-numbering settings for the caret's section, or null (off). */
+    getLineNumbering(): {
+        countBy: number;
+        restart: "continuous" | "newPage" | "newSection";
+        start: number;
+    } | null;
+    /** Leave header/footer editing mode. */
+    closeHeaderFooter(): void;
+    /** Effective formatting of the current selection (toolbar state), or null. */
+    getSelectionFormat(): SelectionFormat | null;
+    /** Print the rendered pages (browser print dialog / save as PDF). */
+    print(): void;
+    /** Serialize the (edited) document back to .docx bytes. */
+    save(): Uint8Array;
+    /** Page count after the latest layout. */
+    pageCount(): number;
+    /**
+     * Suggesting mode: when on, edits record as OOXML tracked changes (w:ins /
+     * w:del) instead of mutating text directly, and the view switches to markup
+     * so the suggestion shows live. `author` stamps the revision (defaults to the
+     * commentAuthor prop). Turning it off restores the prior revision view.
+     */
+    setSuggesting(on: boolean, author?: string): void;
+    isSuggesting(): boolean;
+    /** Accept the tracked change at the caret (keep insertion / apply deletion). */
+    acceptRevisionAtCaret(): boolean;
+    /** Reject the tracked change at the caret (drop insertion / restore deletion). */
+    rejectRevisionAtCaret(): boolean;
+    /** How many tracked changes (suggestions) the document currently holds. */
+    revisionCount(): number;
+    /** Accept every tracked change (one undo step). Returns how many applied. */
+    acceptAllRevisions(): number;
+    /** Reject every tracked change (one undo step). Returns how many applied. */
+    rejectAllRevisions(): number;
+    document: DocxDocument;
+}
+interface DocxViewProps {
+    /** The document: raw bytes, a File/Blob, or a URL to fetch. */
+    source: ArrayBuffer | Uint8Array | Blob | string;
+    /** Zoom factor, 1 = 100%. */
+    zoom?: number;
+    /**
+     * Fit-to-width (Google-Docs mobile behavior): when the page is wider than the
+     * viewport, auto-scale down so it fits with a small gutter and never scrolls
+     * horizontally. The computed scale drives the real `zoom` (crisp text, not a
+     * blurry transform) and is capped at `zoom`, so a wide desktop viewport is
+     * unchanged. Recomputed on container resize. Default true.
+     */
+    fitWidth?: boolean;
+    /**
+     * Container width (px) at or below which the chrome switches to its compact
+     * phone/tablet treatment — the comment rail collapses to tap-to-open cards so
+     * balloons never force horizontal scroll. Default 820.
+     */
+    narrowWidth?: number;
+    /**
+     * Enable editing commands (selection-based formatting, save-back).
+     * Default false: pure render-only viewer.
+     */
+    editable?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    onLoad?: (info: {
+        pageCount: number;
+        document: DocxDocument;
+    }) => void;
+    /** Fires when the document is ready; the api is only usable while mounted. */
+    onReady?: (api: DocxViewApi) => void;
+    onError?: (error: Error) => void;
+    /** Author name stamped on comment replies (default "You"). */
+    commentAuthor?: string;
+    /** Render review comments (range highlights + margin balloons). Default true. */
+    showComments?: boolean;
+    /** Tracked-changes display: "final" (default) or "markup". */
+    revisions?: "final" | "markup";
+    /** Fires after render with document-requested font faces the browser cannot
+     * render (unavailable, or lacking the document's script) — the page is
+     * silently substituting and may differ from Word. Empty array = all good. */
+    onMissingFonts?: (missing: MissingFont[]) => void;
+}
+/**
+ * High-fidelity paginated DOCX viewer (and, with `editable`, editor).
+ *
+ * ```tsx
+ * <DocxView source="/report.docx" />                          // render-only
+ * <DocxView source="/report.docx" editable onReady={setApi} /> // editing
+ * ```
+ */
+declare function DocxView({ source, zoom, fitWidth, narrowWidth, editable, className, style, onLoad, onReady, onError, commentAuthor, showComments, revisions, onMissingFonts, }: DocxViewProps): react.JSX.Element;
+
+export { DocxDocument, DocxToolbar, DocxView, type DocxViewApi, type DocxViewProps, type LineNumberingPatch, type PageLayoutPatch, type ParagraphAlignment, type RunFormatPatch, type SelectionFormat, layoutDocument, printPages, renderToDom };