@docx-editor.dev/editor-api 2.17.0 → 2.19.0

package/dist/{server-Dszoi8AN.d.mts → server-wsxDd90b.d.mts}

@@ -1,12 +1,178 @@
+import { AutomationHandle, AutomationSpan, AutomationOperation, AutomationValue, AutomationSpanRef, AutomationHost, AutomationCapabilities, AutomationPaginationOptions } from '@docx-editor.dev/core/automation';
 import { CollaborationModuleContribution } from '@docx-editor.dev/core/collaboration';
-import { AutomationOperation, AutomationValue, AutomationHandle, AutomationHost, AutomationCapabilities, AutomationSpan } from '@docx-editor.dev/core/automation';
+
+/** Locations used by Office-shaped insertion calls. Each call validates its allowed subset. @public */
+declare enum InsertLocation {
+    replace = "Replace",
+    start = "Start",
+    end = "End",
+    before = "Before",
+    after = "After"
+}
+/** Paragraph alignment vocabulary. Mixed and unknown are read states, not authoring modes. @public */
+declare enum Alignment {
+    mixed = "Mixed",
+    unknown = "Unknown",
+    left = "Left",
+    centered = "Centered",
+    right = "Right",
+    justified = "Justified"
+}
+/** Physical page orientation. @public */
+declare enum PageOrientation {
+    portrait = "Portrait",
+    landscape = "Landscape"
+}
+/** Tracking policy vocabulary. Unsupported policies fail explicitly at sync. @public */
+declare enum ChangeTrackingMode {
+    off = "Off",
+    trackAll = "TrackAll",
+    trackMineOnly = "TrackMineOnly"
+}
+/** Vertical placement of content within a table cell. Mixed cannot be authored. @public */
+declare enum VerticalAlignment {
+    mixed = "Mixed",
+    top = "Top",
+    center = "Center",
+    bottom = "Bottom"
+}
+/** Office break vocabulary; enum presence does not imply support for every break kind. @public */
+declare enum BreakType {
+    line = "Line",
+    page = "Page",
+    next = "Next",
+    sectionNext = "SectionNext",
+    sectionContinuous = "SectionContinuous",
+    sectionEven = "SectionEven",
+    sectionOdd = "SectionOdd"
+}
+/** Content-control kinds, including the read subtypes that insertion does not accept. @public */
+declare enum ContentControlType {
+    unknown = "Unknown",
+    richText = "RichText",
+    plainText = "PlainText",
+    picture = "Picture",
+    buildingBlockGallery = "BuildingBlockGallery",
+    checkBox = "CheckBox",
+    comboBox = "ComboBox",
+    datePicker = "DatePicker",
+    dropDownList = "DropDownList",
+    group = "Group",
+    repeatingSection = "RepeatingSection",
+    plainTextInline = "PlainTextInline",
+    plainTextParagraph = "PlainTextParagraph",
+    richTextInline = "RichTextInline",
+    richTextParagraphs = "RichTextParagraphs",
+    richTextTable = "RichTextTable",
+    richTextTableCell = "RichTextTableCell",
+    richTextTableRow = "RichTextTableRow"
+}
+
+/**
+ * What the host is told to look at.
+ *
+ * Two shapes, because the protocol names two kinds of thing. Most objects ARE something the host
+ * minted a handle for. A stretch of a story is not: it is two endpoints, each a paragraph handle
+ * and a UTF-16 offset, and there is no third object behind it to hand out a handle for. Giving a
+ * range a handle of its own would mean the host tracking a region across every edit, which is a
+ * promise it cannot keep — so the address is the endpoints, and a deleted paragraph makes the
+ * whole address refuse rather than silently name a different place.
+ */
+type ObjectAddress = {
+    readonly kind: 'handle';
+    readonly handle: AutomationHandle;
+} | {
+    readonly kind: 'span';
+    readonly span: AutomationSpan;
+};
+type ObjectPathState = 
+/** Promised: created by a queued read that has not answered yet. */
+{
+    readonly status: 'pending';
+}
+/** Addressable: the host has named this object, or the span it stands for is known. */
+ | {
+    readonly status: 'resolved';
+    readonly address: ObjectAddress;
+}
+/** A `get…OrNullObject` that found nothing. Not an error, and never addressable. */
+ | {
+    readonly status: 'null';
+}
+/** Its run ended without tracking it. Terminal. */
+ | {
+    readonly status: 'released';
+};
+declare class ObjectPath {
+    #private;
+    readonly label: string;
+    private constructor();
+    /** A path that is addressable from the moment it exists — a root, or an item just hydrated. */
+    static of(label: string, handle: AutomationHandle): ObjectPath;
+    /** The same, for an object that IS a stretch of a story. */
+    static ofSpan(label: string, span: AutomationSpan): ObjectPath;
+    /** A path a queued read will fill in — or mark null. */
+    static pending(label: string): ObjectPath;
+    /** A path that is whatever its owner's path is, under its own name. */
+    static derived(label: string, parent: ObjectPath): ObjectPath;
+    get state(): ObjectPathState;
+    get isAddressable(): boolean;
+    get isPending(): boolean;
+    get isNull(): boolean;
+    get isReleased(): boolean;
+    /**
+     * What to put in a batch, or a refusal.
+     *
+     * Both refusals are `InvalidObjectPath` on purpose: from a consumer's side "this object was
+     * released" and "this object is still a promise" are the same mistake — using an object the
+     * runtime cannot address yet or any more — and the `target` says which object it was.
+     *
+     * THE CODE IS ONE THING AND THE MESSAGE IS ANOTHER. The two states have different fixes — a
+     * promise needs a `sync()`, a released object needs to have been tracked — so the sentence in
+     * `errors.ts` names both. It described only the released half for a while, which sent a
+     * consumer holding a perfectly good promised object off to `trackedObjects.add(...)`.
+     */
+    address(): ObjectAddress;
+    /** The handle to address this object with. Refused for anything that is not handle-shaped. */
+    handle(): AutomationHandle;
+    /** The span this object stands for. Refused for anything that is not span-shaped. */
+    span(): AutomationSpan;
+    /**
+     * Hydration: the read answered, and this is the object it named.
+     *
+     * A released path stays released. Hydration arriving for one is not an error — a batch can be
+     * in flight when a run ends — but resurrecting the object would hand back a proxy whose
+     * lifetime rules had already been applied.
+     */
+    resolveTo(handle: AutomationHandle): void;
+    /** The same, for an object that came back as a stretch of a story. */
+    resolveToSpan(span: AutomationSpan): void;
+    /** Hydration: the read answered, and there was nothing there. */
+    resolveNull(): void;
+    /**
+     * The run ended and nothing kept this object alive. Terminal.
+     *
+     * A derived path does not release: its owner's release is what governs it, and releasing here
+     * would let a collection's lifetime end its parent's.
+     */
+    release(): void;
+}
 
 /** Whether an action reads or writes. Drives the conditional-revision rule in `sync()`. */
 type ActionSort = 'read' | 'write';
+
 interface QueuedAction {
     readonly sort: ActionSort;
+    /** Paths that must resolve before this action can be planned. */
+    readonly dependencies?: readonly ObjectPath[];
+    /** A scalar load on an OrNullObject proxy is skipped if its lookup resolves null. */
+    readonly nullableLoad?: ObjectPath;
     /** The consumer-facing name of what this action is for, for errors. Never a handle. */
     readonly label: string;
+    /** Detach coalesced setters when sync captures this action, before asynchronous reads. */
+    capture?(): void;
+    /** Release coalesced state when a batch completes or is discarded. */
+    dispose?(): void;
     /**
      * The host operation for this action.
      *
@@ -91,7 +257,7 @@ declare abstract class ModelObject extends ClientObject {
     /** Queue a read whose text answer becomes the loaded property `name`. */
     protected loadTextInto(name: string, plan: () => AutomationOperation): void;
     /** Queue a command with nothing to answer. Nothing is written until `sync()`. */
-    protected command(name: string, plan: () => AutomationOperation): void;
+    protected command(name: string, plan: () => AutomationOperation, dispose?: () => void): void;
     /**
      * Queue a command whose answer this call has no use for.
      *
@@ -101,7 +267,7 @@ declare abstract class ModelObject extends ClientObject {
      */
     protected commandDiscarding(name: string, plan: () => AutomationOperation): void;
     /** Queue a command whose answer names something the caller keeps. */
-    protected commandAnswering(label: string, plan: () => AutomationOperation, settle: (value: AutomationValue) => void): void;
+    protected commandAnswering(label: string, plan: () => AutomationOperation, settle: (value: AutomationValue) => void, dispose?: () => void): void;
     /** Queue a read whose answer is hydrated by the caller. */
     protected read(label: string, plan: () => AutomationOperation, settle: (value: AutomationValue) => void): void;
     /** The properties a load asked for, refusing any name this object does not have. */
@@ -110,6 +276,25 @@ declare abstract class ModelObject extends ClientObject {
     protected onLoad(request: ResolvedLoadOptions): void;
 }
 
+/** Supported Word bullet styles. @public */
+declare enum ListBullet {
+    custom = "Custom",
+    solid = "Solid",
+    hollow = "Hollow",
+    square = "Square",
+    diamonds = "Diamonds",
+    arrow = "Arrow",
+    checkmark = "Checkmark"
+}
+/** Supported Word numbering styles. @public */
+declare enum ListNumbering {
+    none = "None",
+    arabic = "Arabic",
+    upperRoman = "UpperRoman",
+    lowerRoman = "LowerRoman",
+    upperLetter = "UpperLetter",
+    lowerLetter = "LowerLetter"
+}
 /**
  * A list: the set of paragraphs sharing one numbering id.
  *
@@ -147,6 +332,16 @@ declare class List extends ModelObject implements PromisedItem {
      * `compat/manifest.json`.
      */
     insertParagraph(paragraphText: string, insertLocation: 'Start' | 'End' | 'Before' | 'After'): Paragraph;
+    /** Set a level's bullet glyph. Custom bullets require a Unicode character code. */
+    setLevelBullet(level: number, listBullet: ListBullet, charCode?: number, fontName?: string): void;
+    setLevelBullet(level: number, listBullet: 'Custom' | 'Solid' | 'Hollow' | 'Square' | 'Diamonds' | 'Arrow' | 'Checkmark', charCode?: number, fontName?: string): void;
+    /** Set decimal, letter, Roman, or unnumbered markers. Numeric format entries identify zero-based levels. */
+    setLevelNumbering(level: number, listNumbering: ListNumbering, formatString?: (string | number)[]): void;
+    setLevelNumbering(level: number, listNumbering: 'None' | 'Arabic' | 'UpperRoman' | 'LowerRoman' | 'UpperLetter' | 'LowerLetter', formatString?: (string | number)[]): void;
+    /** Set the starting counter for this list instance without changing other lists. */
+    setLevelStartingNumber(level: number, startingNumber: number): void;
+    /** Set text indent and relative first-line indent in points. Negative relative values create hanging indents. */
+    setLevelIndents(level: number, textIndent: number, bulletNumberPictureIndent: number): void;
     /** @internal Plan the read this object's `load(...)` asked for. */
     protected onLoad(request: ResolvedLoadOptions): void;
 }
@@ -209,6 +404,30 @@ declare class ListItem extends ModelObject {
 /** What the object is, which is what decides how its characters are named. */
 type SpanOwner = 'body' | 'paragraph' | 'span';
 
+/** Office.js underline values. Unsupported runtime modes refuse at sync. @public */
+declare enum UnderlineType {
+    mixed = "Mixed",
+    none = "None",
+    hidden = "Hidden",
+    dotLine = "DotLine",
+    single = "Single",
+    word = "Word",
+    double = "Double",
+    thick = "Thick",
+    dotted = "Dotted",
+    dottedHeavy = "DottedHeavy",
+    dashLine = "DashLine",
+    dashLineHeavy = "DashLineHeavy",
+    dashLineLong = "DashLineLong",
+    dashLineLongHeavy = "DashLineLongHeavy",
+    dotDashLine = "DotDashLine",
+    dotDashLineHeavy = "DotDashLineHeavy",
+    twoDotDashLine = "TwoDotDashLine",
+    twoDotDashLineHeavy = "TwoDotDashLineHeavy",
+    wave = "Wave",
+    waveHeavy = "WaveHeavy",
+    waveDouble = "WaveDouble"
+}
 /**
  * The character formatting of whatever it belongs to: a story, a stretch of one, or a paragraph.
  *
@@ -251,6 +470,18 @@ declare class Font extends ModelObject {
     /** Points. */
     get size(): number | null;
     set size(value: number);
+    /** Office underline styles. Mixed, Hidden, and DotLine refuse at sync. */
+    get underline(): string | null;
+    set underline(value: UnderlineType | 'Mixed' | 'None' | 'Hidden' | 'DotLine' | 'Single' | 'Word' | 'Double' | 'Thick' | 'Dotted' | 'DottedHeavy' | 'DashLine' | 'DashLineHeavy' | 'DashLineLong' | 'DashLineLongHeavy' | 'DotDashLine' | 'DotDashLineHeavy' | 'TwoDotDashLine' | 'TwoDotDashLineHeavy' | 'Wave' | 'WaveHeavy' | 'WaveDouble');
+    /** Exact Word palette color, returned as #RRGGBB. Null clears highlighting. */
+    get highlightColor(): string | null;
+    set highlightColor(value: string);
+    get strikeThrough(): boolean | null;
+    set strikeThrough(value: boolean);
+    get subscript(): boolean | null;
+    set subscript(value: boolean);
+    get superscript(): boolean | null;
+    set superscript(value: boolean);
     /**
      * One read for every property asked for.
      *
@@ -261,18 +492,284 @@ declare class Font extends ModelObject {
     protected onLoad(request: ResolvedLoadOptions): void;
 }
 
+/** Office field types. This runtime authors Page, NumPages, and Empty with a supported code. @public */
+declare enum FieldType {
+    addin = "Addin",
+    addressBlock = "AddressBlock",
+    advance = "Advance",
+    ask = "Ask",
+    author = "Author",
+    autoText = "AutoText",
+    autoTextList = "AutoTextList",
+    barCode = "BarCode",
+    bibliography = "Bibliography",
+    bidiOutline = "BidiOutline",
+    citation = "Citation",
+    comments = "Comments",
+    compare = "Compare",
+    createDate = "CreateDate",
+    data = "Data",
+    database = "Database",
+    date = "Date",
+    displayBarcode = "DisplayBarcode",
+    docProperty = "DocProperty",
+    docVariable = "DocVariable",
+    editTime = "EditTime",
+    embedded = "Embedded",
+    empty = "Empty",
+    eq = "EQ",
+    expression = "Expression",
+    fileName = "FileName",
+    fileSize = "FileSize",
+    fillIn = "FillIn",
+    formCheckbox = "FormCheckbox",
+    formDropdown = "FormDropdown",
+    formText = "FormText",
+    gotoButton = "GotoButton",
+    greetingLine = "GreetingLine",
+    hyperlink = "Hyperlink",
+    if = "If",
+    import = "Import",
+    include = "Include",
+    includePicture = "IncludePicture",
+    includeText = "IncludeText",
+    index = "Index",
+    info = "Info",
+    keywords = "Keywords",
+    lastSavedBy = "LastSavedBy",
+    link = "Link",
+    listNum = "ListNum",
+    macroButton = "MacroButton",
+    mergeBarcode = "MergeBarcode",
+    mergeField = "MergeField",
+    mergeRec = "MergeRec",
+    mergeSeq = "MergeSeq",
+    next = "Next",
+    nextIf = "NextIf",
+    noteRef = "NoteRef",
+    numChars = "NumChars",
+    numPages = "NumPages",
+    numWords = "NumWords",
+    ocx = "OCX",
+    others = "Others",
+    page = "Page",
+    pageRef = "PageRef",
+    print = "Print",
+    printDate = "PrintDate",
+    private = "Private",
+    quote = "Quote",
+    rd = "RD",
+    ref = "Ref",
+    revNum = "RevNum",
+    saveDate = "SaveDate",
+    section = "Section",
+    sectionPages = "SectionPages",
+    seq = "Seq",
+    set = "Set",
+    shape = "Shape",
+    skipIf = "SkipIf",
+    styleRef = "StyleRef",
+    subject = "Subject",
+    subscriber = "Subscriber",
+    symbol = "Symbol",
+    ta = "TA",
+    tc = "TC",
+    template = "Template",
+    time = "Time",
+    title = "Title",
+    toa = "TOA",
+    toc = "TOC",
+    undefined = "Undefined",
+    userAddress = "UserAddress",
+    userInitials = "UserInitials",
+    userName = "UserName",
+    xe = "XE"
+}
+/** String forms of Office field types. @public */
+type FieldTypeLiteral = `${FieldType}`;
+
+/** An inline PNG or JPEG picture. Measurements use points. @public */
+declare class InlinePicture extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal */
+    static at(context: RequestContext, label: string, address: ObjectAddress): InlinePicture;
+    /** @internal */
+    static promised(context: RequestContext, label: string, nullable: boolean): InlinePicture;
+    private constructor();
+    /** @internal */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal */
+    hydrateNull(): void;
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get lockAspectRatio(): boolean;
+    set lockAspectRatio(value: boolean);
+    get altTextDescription(): string;
+    set altTextDescription(value: string);
+    /** Delete this picture. Shared media relationships remain preserved. */
+    delete(): void;
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+/** Inline pictures within a body or range. Load items before enumeration. @public */
+declare class InlinePictureCollection extends ItemCollection<InlinePicture> {
+    #private;
+    /** @internal */
+    static of(context: RequestContext, label: string, owner: ObjectPath, kind: SpanOwner): InlinePictureCollection;
+    private constructor();
+    getFirst(): InlinePicture;
+    getLast(): InlinePicture;
+    getFirstOrNullObject(): InlinePicture;
+    getLastOrNullObject(): InlinePicture;
+    protected listing(): AutomationOperation;
+    protected size(value: AutomationValue, label: string): number;
+    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
+    protected itemAt(label: string, address: ObjectAddress): InlinePicture;
+    protected promised(label: string, nullable: boolean): InlinePicture & PromisedItem;
+}
+
+/** A canonical rectangular table. Reads require load() and sync(). @public */
+declare class Table extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal */
+    static at(context: RequestContext, label: string, address: ObjectAddress): Table;
+    /** @internal */
+    static promised(context: RequestContext, label: string, nullable?: boolean): Table;
+    private constructor();
+    /** @internal */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal */
+    hydrateNull(): void;
+    /** Cell text by row. A write replaces the whole rectangular matrix; rich cell content refuses. */
+    get values(): string[][];
+    set values(value: string[][]);
+    /** Table style display name. Writes must name an existing table style in the document. */
+    get style(): string;
+    set style(value: string);
+    /** Number of consecutive leading rows repeated as table headers. */
+    get headerRowCount(): number;
+    set headerRowCount(value: number);
+    /** Number of rows. Load this property before reading it. */
+    get rowCount(): number;
+    /** Number of columns in the rectangular grid. Load before reading. */
+    get columnCount(): number;
+    /** Stable row collection. Load `items`, then sync before reading its elements. */
+    get rows(): TableRowCollection;
+    /** Address a cell by zero-based row and column. Read-derived operations may share its next sync. */
+    getCell(rowIndex: number, cellIndex: number): TableCell;
+    /** Add rows at an edge. Sync before configuring the returned rows; omitted values create empty cells. */
+    addRows(insertLocation: InsertLocation.start | InsertLocation.end | 'Start' | 'End', rowCount: number, values?: string[][]): TableRowCollection;
+    /** Add columns at an edge. Values are row-major; new columns initially copy the nearest edge width. */
+    addColumns(insertLocation: InsertLocation.start | InsertLocation.end | 'Start' | 'End', columnCount: number, values?: string[][]): void;
+    /** Delete consecutive rows from a zero-based index. Defaults to one row. */
+    deleteRows(rowIndex: number, rowCount?: number): void;
+    /** Delete consecutive columns from a zero-based index. Defaults to one column. */
+    deleteColumns(columnIndex: number, columnCount?: number): void;
+    /** Delete this table and its contents through the canonical document transaction. */
+    delete(): void;
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+/** A row with stable identity. Its cells follow document order. @public */
+declare class TableRow extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal */
+    static at(context: RequestContext, label: string, address: ObjectAddress): TableRow;
+    /** @internal */
+    static promised(context: RequestContext, label: string, nullable?: boolean): TableRow;
+    private constructor();
+    /** @internal */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal */
+    hydrateNull(): void;
+    /** Stable cell collection for this row. Load `items` and sync before reading. */
+    get cells(): TableCellCollection;
+}
+/** An ordinary table cell. Column width uses points and changes the whole grid column. @public */
+declare class TableCell extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal */
+    static at(context: RequestContext, label: string, address: ObjectAddress): TableCell;
+    /** @internal */
+    static promised(context: RequestContext, label: string, nullable?: boolean): TableCell;
+    private constructor();
+    /** @internal */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal */
+    hydrateNull(): void;
+    /** A body scoped to this cell for text, ranges, formatting, and nested table navigation. */
+    get body(): Body;
+    /** Plain cell text. Replacing complex content refuses; use the scoped body for targeted edits. */
+    get value(): string;
+    set value(value: string);
+    /** Width in points. A write affects the whole grid column, not only this cell. */
+    get columnWidth(): number;
+    set columnWidth(value: number);
+    /** Cell background as a supported color string. */
+    get shadingColor(): string;
+    set shadingColor(value: string);
+    /** Top, Center, or Bottom. Mixed is a read state and cannot be assigned. */
+    get verticalAlignment(): VerticalAlignment | 'Top' | 'Center' | 'Bottom' | 'Mixed';
+    set verticalAlignment(value: VerticalAlignment | 'Top' | 'Center' | 'Bottom' | 'Mixed');
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+/** A loaded collection of Table objects. @public */
+declare class TableCollection extends HandleCollection<Table> {
+    #private;
+    /** @internal */
+    static of(context: RequestContext, label: string, owner: ObjectPath, listing: () => AutomationOperation | null): TableCollection;
+    /** @internal */
+    static over(context: RequestContext, label: string, owner: ObjectPath, scope: () => AutomationSpanRef): TableCollection;
+    private constructor();
+    /** Return the first item; an empty collection raises ItemNotFound at sync. */
+    getFirst(): Table;
+    /** Return the first item or a null object. Check isNullObject after sync. */
+    getFirstOrNullObject(): Table;
+    protected listing(): AutomationOperation | null;
+    protected itemAt(label: string, address: ObjectAddress): Table;
+    protected promised(label: string, nullable: boolean): Table & PromisedItem;
+}
+/** A loaded collection of TableRow objects. @public */
+declare class TableRowCollection extends HandleCollection<TableRow> {
+    #private;
+    /** @internal */
+    static of(context: RequestContext, label: string, owner: ObjectPath, listing: () => AutomationOperation | null): TableRowCollection;
+    private constructor();
+    /** Return the first item; an empty collection raises ItemNotFound at sync. */
+    getFirst(): TableRow;
+    /** Return the first item or a null object. Check isNullObject after sync. */
+    getFirstOrNullObject(): TableRow;
+    protected listing(): AutomationOperation | null;
+    protected itemAt(label: string, address: ObjectAddress): TableRow;
+    protected promised(label: string, nullable: boolean): TableRow & PromisedItem;
+}
+/** A loaded collection of TableCell objects. @public */
+declare class TableCellCollection extends HandleCollection<TableCell> {
+    #private;
+    /** @internal */
+    static of(context: RequestContext, label: string, owner: ObjectPath, listing: () => AutomationOperation | null): TableCellCollection;
+    private constructor();
+    /** Return the first item; an empty collection raises ItemNotFound at sync. */
+    getFirst(): TableCell;
+    /** Return the first item or a null object. Check isNullObject after sync. */
+    getFirstOrNullObject(): TableCell;
+    protected listing(): AutomationOperation | null;
+    protected itemAt(label: string, address: ObjectAddress): TableCell;
+    protected promised(label: string, nullable: boolean): TableCell & PromisedItem;
+}
+
 /** Every place this API can insert at. Individual members accept a subset. */
-type InsertLocation = 'Replace' | 'Start' | 'End' | 'Before' | 'After';
+
 /** Where a story accepts text: over all of it, or at either edge. */
-type BodyInsertTextLocation = Extract<InsertLocation, 'Replace' | 'Start' | 'End'>;
+type BodyInsertTextLocation = Extract<RangeInsertTextLocation, 'Replace' | 'Start' | 'End'>;
 /** Where a story accepts a paragraph. `Start`/`End` mean "before the first"/"after the last". */
-type BodyInsertParagraphLocation = Extract<InsertLocation, 'Start' | 'End'>;
+type BodyInsertParagraphLocation = Extract<RangeInsertTextLocation, 'Start' | 'End'>;
 /** Where a paragraph accepts text: over all of it, or at either edge of it. */
-type ParagraphInsertTextLocation = Extract<InsertLocation, 'Replace' | 'Start' | 'End'>;
+type ParagraphInsertTextLocation = Extract<RangeInsertTextLocation, 'Replace' | 'Start' | 'End'>;
 /** Which side of a paragraph or a range a new paragraph goes on. */
-type BesideLocation = Extract<InsertLocation, 'Before' | 'After'>;
+type BesideLocation = Extract<RangeInsertTextLocation, 'Before' | 'After'>;
 /** Where a range accepts text. See `Range#insertText` for what `Before`/`Start` mean here. */
-type RangeInsertTextLocation = InsertLocation;
+type RangeInsertTextLocation = 'Replace' | 'Start' | 'End' | 'Before' | 'After';
 /** Where a selection lands: over the range, or collapsed to one of its edges. */
 type SelectionMode = 'Select' | 'Start' | 'End';
 
@@ -338,9 +835,194 @@ declare class BookmarkCollection extends HandleCollection<Bookmark> {
     /** @internal The read that answers this collection's members. */
     protected listing(): AutomationOperation;
     /** @internal Build one member from an address the listing answered. */
-    protected itemAt(label: string, address: ObjectAddress): Bookmark;
+    protected itemAt(label: string, address: ObjectAddress): Bookmark;
+    /** @internal A member an edge accessor named before the sync that finds it. */
+    protected promised(label: string, nullable: boolean): Bookmark & PromisedItem;
+}
+
+/**
+ * What a control's own type accepts as a value.
+ *
+ * A discriminated union rather than `unknown`: a dropdown and a checkbox do not take the same
+ * kind of thing, and a single `setValue(value: string)` would have to guess what `'true'` means
+ * to a date picker.
+ */
+type ContentControlValue = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'listItem';
+    readonly value: string;
+} | {
+    readonly kind: 'checkbox';
+    readonly checked: boolean;
+}
+/** `YYYY-MM-DD`, or a full ISO-8601 instant. */
+ | {
+    readonly kind: 'date';
+    readonly iso: string;
+};
+/** The lock a control carries. `ST_Lock`, spelled as the schema spells it. */
+type ContentControlLockState = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
+/** The control types this API can create. Picture and repeating section are deferred. */
+type ContentControlSubtype = 'richText' | 'plainText' | 'dropDownList' | 'comboBox' | 'date';
+/**
+ * A part of a document a template marked as a field.
+ *
+ * A control is NOT its `w:id`. The attribute is optional in OOXML and unique nowhere, so a
+ * document may hold one control with no id and two with the same one. This object is addressed by
+ * an opaque host-minted handle instead, and {@link ContentControl.id} is answered as METADATA — a
+ * label the file wrote, empty where it wrote none. `getById` still exists, because a template
+ * author knows their own numbering, and it answers the first match in document order rather than
+ * refusing.
+ *
+ * A control's contents are not its value. `text` reads the characters; `setValue` writes in the
+ * vocabulary the control's own type accepts — a declared item for a dropdown, an ISO date for a
+ * date picker, a state for a checkbox — because writing `"true"` into a checkbox's runs would
+ * produce a document whose glyph and whose `w14:checked` disagree.
+ *
+ * @public
+ */
+declare class ContentControl extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal A control a read has already named. */
+    static at(context: RequestContext, label: string, address: ObjectAddress): ContentControl;
+    /** @internal A control a queued read will name, or report as nothing. */
+    static promised(context: RequestContext, label: string, nullable: boolean): ContentControl;
+    private constructor();
+    /** @internal Bind this object to the address the owning read answered. */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal Settle as the null object: the read found nothing to name. */
+    hydrateNull(): void;
+    /**
+     * The `w:id` the file wrote, as a string, and `''` where it wrote none.
+     *
+     * A STRING and not a number, deliberately. The identity of this object is its handle; a numeric
+     * `id` invites a caller to key a map on a value the schema lets a document repeat.
+     */
+    get id(): string;
+    /** `w:tag` — the machine-readable label a template puts on a field. `''` where absent. */
+    get tag(): string;
+    set tag(value: string);
+    /** `w:alias` — what Word's UI calls the control's title. `''` where absent. */
+    get title(): string;
+    set title(value: string);
+    /** What kind of control it is: `plainText`, `dropDownList`, `checkbox`, `date`, … */
+    get subtype(): string;
+    /**
+     * Whether the control currently declares an OOXML data binding.
+     *
+     * This is advisory preflight for callers choosing controls to write. A document can change
+     * after this property is loaded, so the atomic sync-time refusal remains the final authority.
+     * Only binding presence is exposed: XPath, namespace mappings, store ids, and custom XML
+     * content remain inside the untrusted-document boundary.
+     */
+    get isBound(): boolean;
+    /**
+     * Whether the control refuses to be deleted.
+     *
+     * Reads the lock IN FORCE, so a control an enclosing one protects reports true even when its
+     * own `w:lock` says otherwise — that is what the document does, and reporting the control's own
+     * half would tell a caller an edit will work when the store is about to refuse it.
+     */
+    get cannotDelete(): boolean;
+    set cannotDelete(value: boolean);
+    /** Whether the control's contents refuse to be edited. Resolved like `cannotDelete`. */
+    get cannotEdit(): boolean;
+    set cannotEdit(value: boolean);
+    /**
+     * Whether the control is showing its prompt rather than a value (`w:showingPlcHdr`).
+     *
+     * STATE, not text. A control showing its placeholder holds the prompt in its runs, and the
+     * first thing written into it replaces the whole prompt — so a caller that treats `text` as a
+     * value must ask this before believing it.
+     */
+    get placeholderShown(): boolean;
+    /** Whether the control removes its own wrapper on the first content edit (`w:temporary`). */
+    get temporary(): boolean;
+    /** The characters the control encloses, as the document reads them. */
+    get text(): string;
+    /** The paragraphs the control holds. Empty for an inline control, which holds none. */
+    get paragraphs(): ParagraphCollection;
+    /** The controls INSIDE this one, in document order. */
+    get contentControls(): ContentControlCollection;
+    /**
+     * The stretch of the story the control's content covers.
+     *
+     * Read when it is asked for rather than carried by the control, because the content moves as
+     * the document is edited: the range a caller gets is where the control is now.
+     */
+    getRange(rangeLocation?: 'Whole' | 'Start' | 'End' | 'Before' | 'After' | 'Content'): Range;
+    /**
+     * Write the control's value.
+     *
+     * The refusals belong to the document, not to this method: a locked control, a control the file
+     * bound to custom XML, and a value the control's type does not accept are all refused by the
+     * engine's single write path, which is the same path a keystroke takes. {@link isBound} is an
+     * advisory preflight only; this sync-time check remains authoritative if the document changed
+     * after the flag was loaded.
+     */
+    setValue(value: ContentControlValue): void;
+    /**
+     * Put text into the control: over what it holds, or at one end of it.
+     *
+     * `Replace` goes through the control's own value path, so the prompt it was showing and a
+     * `w:temporary` wrapper are dealt with there rather than a second time here. The range comes
+     * back from the WRITE and not from a read beside it: reads answer the document as it is when
+     * the batch is planned, so a read here would name the text the write was about to replace.
+     */
+    insertText(text: string, insertLocation: InsertLocation.replace | InsertLocation.start | InsertLocation.end | 'Replace' | 'Start' | 'End'): Range;
+    /**
+     * Remove the control.
+     *
+     * `keepContent` true is Word's own "Remove content control": the wrapper goes and the text it
+     * held stays exactly where it was. False takes the content with it.
+     */
+    delete(keepContent: boolean): void;
+    /** @internal Plan the read this object's `load(...)` asked for. */
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+/** Where a collection of controls looks: a story, or inside one control. */
+type ContentControlScope = {
+    readonly body: AutomationHandle;
+} | {
+    readonly contentControl: AutomationHandle;
+};
+/**
+ * The content controls of a document, story or range, as of the batch that loaded them.
+ *
+ * `getById` answers the first match in document order, because `w:id` is optional in OOXML and
+ * unique nowhere — see {@link ContentControl} for why choosing predictably beats refusing.
+ *
+ * @public
+ */
+declare class ContentControlCollection extends HandleCollection<ContentControl> {
+    #private;
+    /** @internal The controls of a scope, in document order. */
+    static of(context: RequestContext, label: string, owner: ObjectPath, scope: ContentControlScope): ContentControlCollection;
+    private constructor();
+    /** The first control. `ItemNotFound` at the sync if the scope holds none. */
+    getFirst(): ContentControl;
+    /** The first control, or an object that says `isNullObject` where there is none. */
+    getFirstOrNullObject(): ContentControl;
+    /**
+     * The first control carrying one `w:id`, or `ItemNotFound` where the scope holds none.
+     *
+     * FIRST in document order, because `w:id` is not unique. The lookup is one read answered by the
+     * host: matching it here would mean asking every control for its id and choosing locally, which
+     * is a batch whose size depends on how many controls the document has.
+     */
+    getById(id: number): ContentControl;
+    /** Every control in the scope carrying one tag, in document order. */
+    getByTag(tag: string): ContentControlCollection;
+    /** Every control in the scope carrying one title, in document order. */
+    getByTitle(title: string): ContentControlCollection;
+    /** @internal The read that answers this collection's members. */
+    protected listing(): AutomationOperation;
+    /** @internal Build one member from an address the listing answered. */
+    protected itemAt(label: string, address: ObjectAddress): ContentControl;
     /** @internal A member an edge accessor named before the sync that finds it. */
-    protected promised(label: string, nullable: boolean): Bookmark & PromisedItem;
+    protected promised(label: string, nullable: boolean): ContentControl & PromisedItem;
 }
 
 /**
@@ -641,6 +1323,8 @@ declare class Range extends ModelObject implements PromisedItem {
      * WRITING IT AUTHORS A LINK over exactly these characters, and `''` removes one. A URL whose
      * scheme this engine would refuse to OPEN is refused here too, by the same allowlist: a document
      * this API writes must not be one it would then decline to follow.
+     * Partial retargeting and unlinking support ordinary text links directly inside a paragraph.
+     * Complex or nested link wrappers and collapsed ranges inside links refuse with `NotSupported`.
      */
     get hyperlink(): string;
     set hyperlink(value: string);
@@ -663,7 +1347,7 @@ declare class Range extends ModelObject implements PromisedItem {
      * snapshot. Both pairs are accepted because source-compatible code uses all four; what a caller
      * gets back is a range naming the text that was written, in every case.
      */
-    insertText(text: string, insertLocation: 'Replace' | 'Start' | 'End' | 'Before' | 'After'): Range;
+    insertText(text: string, insertLocation: InsertLocation | 'Replace' | 'Start' | 'End' | 'Before' | 'After'): Range;
     /** Delete this range's content. TrackMineOnly preserves inline text as a pending deletion. */
     delete(): void;
     /** Clear this range's content, preserving the surrounding structure. */
@@ -676,8 +1360,27 @@ declare class Range extends ModelObject implements PromisedItem {
      * approximately. A collapsed range creates an insertion-point comment.
      */
     insertComment(commentText: string): Comment;
+    /**
+     * Wrap this single-paragraph range in a rich-text or plain-text content control.
+     * Await sync before configuring the returned control. Other types explicitly refuse.
+     */
+    insertContentControl(contentControlType?: ContentControlType.richText | ContentControlType.plainText | ContentControlType.buildingBlockGallery | ContentControlType.checkBox | ContentControlType.comboBox | ContentControlType.datePicker | ContentControlType.dropDownList | ContentControlType.group | ContentControlType.picture | ContentControlType.repeatingSection | 'RichText' | 'PlainText' | 'BuildingBlockGallery' | 'CheckBox' | 'ComboBox' | 'DatePicker' | 'DropDownList' | 'Group' | 'Picture' | 'RepeatingSection'): ContentControl;
+    /** Tables contained by this range, in document order. */
+    get tables(): TableCollection;
+    /** Fields fully contained within this range. */
+    get fields(): FieldCollection;
+    insertField(insertLocation: InsertLocation | 'Before' | 'After' | 'Start' | 'End' | 'Replace', fieldType?: FieldType, text?: string, removeFormatting?: boolean): Field;
+    insertField(insertLocation: InsertLocation | 'Before' | 'After' | 'Start' | 'End' | 'Replace', fieldType?: FieldTypeLiteral, text?: string, removeFormatting?: boolean): Field;
+    /** Inline pictures fully contained within this snapshot range. */
+    get inlinePictures(): InlinePictureCollection;
+    /** Insert a bounded PNG/JPEG image. Sync before configuring the returned picture. */
+    insertInlinePictureFromBase64(base64EncodedImage: string, insertLocation: InsertLocation | 'Before' | 'After' | 'Start' | 'End' | 'Replace'): InlinePicture;
+    /** Page and next-page section breaks are supported; other break types refuse at sync. */
+    insertBreak(breakType: BreakType | 'Page' | 'SectionNext' | 'Next' | 'Line' | 'SectionContinuous' | 'SectionEven' | 'SectionOdd', insertLocation: InsertLocation.before | InsertLocation.after | 'Before' | 'After'): void;
+    /** Insert a rectangular table before or after this range. */
+    insertTable(rowCount: number, columnCount: number, insertLocation: InsertLocation.before | InsertLocation.after | 'Before' | 'After', values?: string[][]): Table;
     /** Add a paragraph before or after the one this range starts or ends in. */
-    insertParagraph(paragraphText: string, insertLocation: 'Before' | 'After'): Paragraph;
+    insertParagraph(paragraphText: string, insertLocation: InsertLocation.before | InsertLocation.after | 'Before' | 'After'): Paragraph;
     /**
      * Put the reader's selection on this range and navigate the editor viewport to it.
      *
@@ -696,7 +1399,7 @@ declare class Range extends ModelObject implements PromisedItem {
 }
 
 /** Paragraph alignment values readable and writable through this object model. */
-type ParagraphAlignment = 'Mixed' | 'Unknown' | 'Left' | 'Centered' | 'Right' | 'Justified';
+type ParagraphAlignment = Alignment | 'Mixed' | 'Unknown' | 'Left' | 'Centered' | 'Right' | 'Justified';
 /**
  * One paragraph: what it says, what it is, and the ways it can be changed.
  *
@@ -763,313 +1466,136 @@ declare class Paragraph extends ModelObject implements PromisedItem {
     /** Points. */
     get rightIndent(): number;
     set rightIndent(value: number);
-    /** Points between the paragraph's lines. */
-    get lineSpacing(): number;
-    set lineSpacing(value: number);
-    /** Points above the paragraph. */
-    get spaceBefore(): number;
-    set spaceBefore(value: number);
-    /** Points below the paragraph. */
-    get spaceAfter(): number;
-    set spaceAfter(value: number);
-    /**
-     * The list this paragraph is in.
-     *
-     * A paragraph in NO list refuses the batch (`InvalidArgument`), the way upstream's own accessor
-     * throws: a list a paragraph is not in has no members to answer, and a null object here would
-     * make "not numbered" indistinguishable from "numbered by a list this document has lost".
-     */
-    get list(): List;
-    /** Where this paragraph sits in its list. Reading `level` on a paragraph in none refuses. */
-    get listItem(): ListItem;
-    /** Empty this paragraph's text, leaving the paragraph itself where it is. */
-    clear(): void;
-    /** Remove this paragraph and everything in it. */
-    delete(): void;
-    /** Write text over this paragraph or at either edge of it. Answers the written text's range. */
-    insertText(text: string, insertLocation: 'Replace' | 'Start' | 'End'): Range;
-    /** Add a paragraph beside this one. Answers the new paragraph. */
-    insertParagraph(paragraphText: string, insertLocation: 'Before' | 'After'): Paragraph;
-    /**
-     * Break this paragraph at every occurrence of any delimiter.
-     *
-     * Answers one range per resulting paragraph, in reading order, INCLUDING the piece that keeps
-     * this paragraph's identity — so a caller can read back what each piece became without having to
-     * work out which of them is the original. The collection is filled by the split itself: there is
-     * no second read, because a second read would describe the document the split had already made.
-     */
-    split(delimiters: string[], trimDelimiters?: boolean, trimSpacing?: boolean): RangeCollection;
-    /** @internal Plan the read this object's `load(...)` asked for. */
-    protected onLoad(request: ResolvedLoadOptions): void;
-}
-
-/**
- * The paragraphs of a story, a range, or a list, as of the batch that loaded them.
- *
- * Contains paragraphs at every depth — inside table cells, nested tables, and block-level content
- * controls — matching Word's own collection rather than only the owner's direct children.
- *
- * One of the two collections whose members are not plain handles: the pieces a
- * {@link Paragraph.split} answers are filled in by the split's own command rather than by a
- * separate listing read.
- *
- * @public
- */
-declare class ParagraphCollection extends ItemCollection<Paragraph> {
-    #private;
-    /** @internal A story's paragraphs, or a range's, depending on the path it derives from. */
-    static of(context: RequestContext, label: string, owner: ObjectPath): ParagraphCollection;
-    /**
-     * @internal Paragraphs a named read answers: a list's items, or one level of them.
-     *
-     * The owner's own address does not say which paragraphs are wanted — a list is not a place in the
-     * story, it is a set of them — so the operation is supplied instead of derived.
-     */
-    static overListing(context: RequestContext, label: string, owner: ObjectPath, plan: () => AutomationOperation): ParagraphCollection;
-    private constructor();
-    /** The first paragraph. `ItemNotFound` at the sync if the collection holds none. */
-    getFirst(): Paragraph;
-    /** The last paragraph. `ItemNotFound` at the sync if the collection holds none. */
-    getLast(): Paragraph;
-    /** The first paragraph, or an object that will report `isNullObject`. */
-    getFirstOrNullObject(): Paragraph;
-    /** The last paragraph, or an object that will report `isNullObject`. */
-    getLastOrNullObject(): Paragraph;
-    /** @internal The read that answers this collection's members. */
-    protected listing(): AutomationOperation;
-    /** @internal How many members the listing's answer describes. */
-    protected size(value: AutomationValue, label: string): number;
-    /** @internal The address of one member of the listing's answer. */
-    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
-    /** @internal Build one member from an address the listing answered. */
-    protected itemAt(label: string, address: ObjectAddress): Paragraph;
-    /** @internal A member an edge accessor named before the sync that finds it. */
-    protected promised(label: string, nullable: boolean): Paragraph & PromisedItem;
-}
-/**
- * Ranges a read produced — the hits of a search, or the pieces a split answered.
- *
- * Its members are SPANS rather than handles, which is what separates it from the handle-backed
- * collections: each item carries its own paragraph-plus-offset endpoints instead of an opaque
- * host-minted id.
- *
- * @public
- */
-declare class RangeCollection extends ItemCollection<Range> {
-    #private;
-    /** @internal Ranges a read answers: where some text occurs. */
-    static of(context: RequestContext, label: string, owner: ObjectPath, plan: () => AutomationOperation): RangeCollection;
-    /** @internal Ranges a command answers: the pieces a split produced. Filled by that command. */
-    static answered(context: RequestContext, label: string, owner: ObjectPath): RangeCollection;
-    private constructor();
-    /** The first range. `ItemNotFound` at the sync if nothing matched. */
-    getFirst(): Range;
-    /**
-     * The last range. `ItemNotFound` at the sync if nothing matched.
-     *
-     * A DocxEditor member rather than a compatibility one: the reference's range collection publishes
-     * only its first, and the pieces of a split are the case that makes the other end worth having —
-     * "the paragraph this one ended up as" is the last piece, and counting `items` to find it means
-     * loading them all. Recorded as an omission in `compat/manifest.json` for that reason.
-     */
-    getLast(): Range;
-    /** The first range, or an object that will report `isNullObject`. */
-    getFirstOrNullObject(): Range;
-    /** @internal The read that answers this collection's members. */
-    protected listing(): AutomationOperation | null;
-    /** @internal How many members the listing's answer describes. */
-    protected size(value: AutomationValue, label: string): number;
-    /** @internal The address of one member of the listing's answer. */
-    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
-    /** @internal Build one member from an address the listing answered. */
-    protected itemAt(label: string, address: ObjectAddress): Range;
-    /** @internal A member an edge accessor named before the sync that finds it. */
-    protected promised(label: string, nullable: boolean): Range & PromisedItem;
-}
-
-/**
- * What a control's own type accepts as a value.
- *
- * A discriminated union rather than `unknown`: a dropdown and a checkbox do not take the same
- * kind of thing, and a single `setValue(value: string)` would have to guess what `'true'` means
- * to a date picker.
- */
-type ContentControlValue = {
-    readonly kind: 'text';
-    readonly text: string;
-} | {
-    readonly kind: 'listItem';
-    readonly value: string;
-} | {
-    readonly kind: 'checkbox';
-    readonly checked: boolean;
-}
-/** `YYYY-MM-DD`, or a full ISO-8601 instant. */
- | {
-    readonly kind: 'date';
-    readonly iso: string;
-};
-/** The lock a control carries. `ST_Lock`, spelled as the schema spells it. */
-type ContentControlLockState = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
-/** The control types this API can create. Picture and repeating section are deferred. */
-type ContentControlSubtype = 'richText' | 'plainText' | 'dropDownList' | 'comboBox' | 'date';
-/**
- * A part of a document a template marked as a field.
- *
- * A control is NOT its `w:id`. The attribute is optional in OOXML and unique nowhere, so a
- * document may hold one control with no id and two with the same one. This object is addressed by
- * an opaque host-minted handle instead, and {@link ContentControl.id} is answered as METADATA — a
- * label the file wrote, empty where it wrote none. `getById` still exists, because a template
- * author knows their own numbering, and it answers the first match in document order rather than
- * refusing.
- *
- * A control's contents are not its value. `text` reads the characters; `setValue` writes in the
- * vocabulary the control's own type accepts — a declared item for a dropdown, an ISO date for a
- * date picker, a state for a checkbox — because writing `"true"` into a checkbox's runs would
- * produce a document whose glyph and whose `w14:checked` disagree.
- *
- * @public
- */
-declare class ContentControl extends ModelObject implements PromisedItem {
-    #private;
-    /** @internal A control a read has already named. */
-    static at(context: RequestContext, label: string, address: ObjectAddress): ContentControl;
-    /** @internal A control a queued read will name, or report as nothing. */
-    static promised(context: RequestContext, label: string, nullable: boolean): ContentControl;
-    private constructor();
-    /** @internal Bind this object to the address the owning read answered. */
-    hydrateAddress(address: ObjectAddress): void;
-    /** @internal Settle as the null object: the read found nothing to name. */
-    hydrateNull(): void;
-    /**
-     * The `w:id` the file wrote, as a string, and `''` where it wrote none.
-     *
-     * A STRING and not a number, deliberately. The identity of this object is its handle; a numeric
-     * `id` invites a caller to key a map on a value the schema lets a document repeat.
-     */
-    get id(): string;
-    /** `w:tag` — the machine-readable label a template puts on a field. `''` where absent. */
-    get tag(): string;
-    set tag(value: string);
-    /** `w:alias` — what Word's UI calls the control's title. `''` where absent. */
-    get title(): string;
-    set title(value: string);
-    /** What kind of control it is: `plainText`, `dropDownList`, `checkbox`, `date`, … */
-    get subtype(): string;
-    /**
-     * Whether the control currently declares an OOXML data binding.
-     *
-     * This is advisory preflight for callers choosing controls to write. A document can change
-     * after this property is loaded, so the atomic sync-time refusal remains the final authority.
-     * Only binding presence is exposed: XPath, namespace mappings, store ids, and custom XML
-     * content remain inside the untrusted-document boundary.
-     */
-    get isBound(): boolean;
-    /**
-     * Whether the control refuses to be deleted.
-     *
-     * Reads the lock IN FORCE, so a control an enclosing one protects reports true even when its
-     * own `w:lock` says otherwise — that is what the document does, and reporting the control's own
-     * half would tell a caller an edit will work when the store is about to refuse it.
-     */
-    get cannotDelete(): boolean;
-    set cannotDelete(value: boolean);
-    /** Whether the control's contents refuse to be edited. Resolved like `cannotDelete`. */
-    get cannotEdit(): boolean;
-    set cannotEdit(value: boolean);
-    /**
-     * Whether the control is showing its prompt rather than a value (`w:showingPlcHdr`).
-     *
-     * STATE, not text. A control showing its placeholder holds the prompt in its runs, and the
-     * first thing written into it replaces the whole prompt — so a caller that treats `text` as a
-     * value must ask this before believing it.
-     */
-    get placeholderShown(): boolean;
-    /** Whether the control removes its own wrapper on the first content edit (`w:temporary`). */
-    get temporary(): boolean;
-    /** The characters the control encloses, as the document reads them. */
-    get text(): string;
-    /** The paragraphs the control holds. Empty for an inline control, which holds none. */
-    get paragraphs(): ParagraphCollection;
-    /** The controls INSIDE this one, in document order. */
-    get contentControls(): ContentControlCollection;
-    /**
-     * The stretch of the story the control's content covers.
-     *
-     * Read when it is asked for rather than carried by the control, because the content moves as
-     * the document is edited: the range a caller gets is where the control is now.
-     */
-    getRange(rangeLocation?: 'Whole' | 'Start' | 'End' | 'Before' | 'After' | 'Content'): Range;
+    /** Points between the paragraph's lines. */
+    get lineSpacing(): number;
+    set lineSpacing(value: number);
+    /** Points above the paragraph. */
+    get spaceBefore(): number;
+    set spaceBefore(value: number);
+    /** Points below the paragraph. */
+    get spaceAfter(): number;
+    set spaceAfter(value: number);
     /**
-     * Write the control's value.
+     * The list this paragraph is in.
      *
-     * The refusals belong to the document, not to this method: a locked control, a control the file
-     * bound to custom XML, and a value the control's type does not accept are all refused by the
-     * engine's single write path, which is the same path a keystroke takes. {@link isBound} is an
-     * advisory preflight only; this sync-time check remains authoritative if the document changed
-     * after the flag was loaded.
+     * A paragraph in NO list refuses the batch (`InvalidArgument`), the way upstream's own accessor
+     * throws: a list a paragraph is not in has no members to answer, and a null object here would
+     * make "not numbered" indistinguishable from "numbered by a list this document has lost".
      */
-    setValue(value: ContentControlValue): void;
+    get list(): List;
+    /** Address this paragraph's content or an endpoint. Sync before using the returned range. */
+    getRange(rangeLocation?: 'Whole' | 'Content' | 'Start' | 'End' | 'Before' | 'After'): Range;
+    /** Start a new independent bullet list with this paragraph. Sync before using the returned list. */
+    startNewList(): List;
+    /** Join an existing list at a zero-based nesting level. */
+    attachToList(listId: number, level: number): List;
+    /** Remove numbering while preserving the paragraph's text and other formatting. */
+    detachFromList(): void;
+    /** Where this paragraph sits in its list. Reading `level` on a paragraph in none refuses. */
+    get listItem(): ListItem;
+    /** Empty this paragraph's text, leaving the paragraph itself where it is. */
+    clear(): void;
+    /** Remove this paragraph and everything in it. */
+    delete(): void;
+    /** Write text over this paragraph or at either edge of it. Answers the written text's range. */
+    insertText(text: string, insertLocation: InsertLocation.replace | InsertLocation.start | InsertLocation.end | 'Replace' | 'Start' | 'End'): Range;
+    /** Add a paragraph beside this one. Answers the new paragraph. */
+    insertParagraph(paragraphText: string, insertLocation: 'Before' | 'After'): Paragraph;
     /**
-     * Put text into the control: over what it holds, or at one end of it.
+     * Break this paragraph at every occurrence of any delimiter.
      *
-     * `Replace` goes through the control's own value path, so the prompt it was showing and a
-     * `w:temporary` wrapper are dealt with there rather than a second time here. The range comes
-     * back from the WRITE and not from a read beside it: reads answer the document as it is when
-     * the batch is planned, so a read here would name the text the write was about to replace.
+     * Answers one range per resulting paragraph, in reading order, INCLUDING the piece that keeps
+     * this paragraph's identity — so a caller can read back what each piece became without having to
+     * work out which of them is the original. The collection is filled by the split itself: there is
+     * no second read, because a second read would describe the document the split had already made.
      */
-    insertText(text: string, insertLocation: 'Replace' | 'Start' | 'End'): Range;
+    split(delimiters: string[], trimDelimiters?: boolean, trimSpacing?: boolean): RangeCollection;
+    /** @internal Plan the read this object's `load(...)` asked for. */
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+
+/**
+ * The paragraphs of a story, a range, or a list, as of the batch that loaded them.
+ *
+ * Contains paragraphs at every depth — inside table cells, nested tables, and block-level content
+ * controls — matching Word's own collection rather than only the owner's direct children.
+ *
+ * One of the two collections whose members are not plain handles: the pieces a
+ * {@link Paragraph.split} answers are filled in by the split's own command rather than by a
+ * separate listing read.
+ *
+ * @public
+ */
+declare class ParagraphCollection extends ItemCollection<Paragraph> {
+    #private;
+    /** @internal A story's paragraphs, or a range's, depending on the path it derives from. */
+    static of(context: RequestContext, label: string, owner: ObjectPath): ParagraphCollection;
     /**
-     * Remove the control.
+     * @internal Paragraphs a named read answers: a list's items, or one level of them.
      *
-     * `keepContent` true is Word's own "Remove content control": the wrapper goes and the text it
-     * held stays exactly where it was. False takes the content with it.
+     * The owner's own address does not say which paragraphs are wanted — a list is not a place in the
+     * story, it is a set of them — so the operation is supplied instead of derived.
      */
-    delete(keepContent: boolean): void;
-    /** @internal Plan the read this object's `load(...)` asked for. */
-    protected onLoad(request: ResolvedLoadOptions): void;
+    static overListing(context: RequestContext, label: string, owner: ObjectPath, plan: () => AutomationOperation): ParagraphCollection;
+    private constructor();
+    /** The first paragraph. `ItemNotFound` at the sync if the collection holds none. */
+    getFirst(): Paragraph;
+    /** The last paragraph. `ItemNotFound` at the sync if the collection holds none. */
+    getLast(): Paragraph;
+    /** The first paragraph, or an object that will report `isNullObject`. */
+    getFirstOrNullObject(): Paragraph;
+    /** The last paragraph, or an object that will report `isNullObject`. */
+    getLastOrNullObject(): Paragraph;
+    /** @internal The read that answers this collection's members. */
+    protected listing(): AutomationOperation;
+    /** @internal How many members the listing's answer describes. */
+    protected size(value: AutomationValue, label: string): number;
+    /** @internal The address of one member of the listing's answer. */
+    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
+    /** @internal Build one member from an address the listing answered. */
+    protected itemAt(label: string, address: ObjectAddress): Paragraph;
+    /** @internal A member an edge accessor named before the sync that finds it. */
+    protected promised(label: string, nullable: boolean): Paragraph & PromisedItem;
 }
-/** Where a collection of controls looks: a story, or inside one control. */
-type ContentControlScope = {
-    readonly body: AutomationHandle;
-} | {
-    readonly contentControl: AutomationHandle;
-};
 /**
- * The content controls of a document, story or range, as of the batch that loaded them.
+ * Ranges a read produced — the hits of a search, or the pieces a split answered.
  *
- * `getById` answers the first match in document order, because `w:id` is optional in OOXML and
- * unique nowhere — see {@link ContentControl} for why choosing predictably beats refusing.
+ * Its members are SPANS rather than handles, which is what separates it from the handle-backed
+ * collections: each item carries its own paragraph-plus-offset endpoints instead of an opaque
+ * host-minted id.
  *
  * @public
  */
-declare class ContentControlCollection extends HandleCollection<ContentControl> {
+declare class RangeCollection extends ItemCollection<Range> {
     #private;
-    /** @internal The controls of a scope, in document order. */
-    static of(context: RequestContext, label: string, owner: ObjectPath, scope: ContentControlScope): ContentControlCollection;
+    /** @internal Ranges a read answers: where some text occurs. */
+    static of(context: RequestContext, label: string, owner: ObjectPath, plan: () => AutomationOperation): RangeCollection;
+    /** @internal Ranges a command answers: the pieces a split produced. Filled by that command. */
+    static answered(context: RequestContext, label: string, owner: ObjectPath): RangeCollection;
     private constructor();
-    /** The first control. `ItemNotFound` at the sync if the scope holds none. */
-    getFirst(): ContentControl;
-    /** The first control, or an object that says `isNullObject` where there is none. */
-    getFirstOrNullObject(): ContentControl;
+    /** The first range. `ItemNotFound` at the sync if nothing matched. */
+    getFirst(): Range;
     /**
-     * The first control carrying one `w:id`, or `ItemNotFound` where the scope holds none.
+     * The last range. `ItemNotFound` at the sync if nothing matched.
      *
-     * FIRST in document order, because `w:id` is not unique. The lookup is one read answered by the
-     * host: matching it here would mean asking every control for its id and choosing locally, which
-     * is a batch whose size depends on how many controls the document has.
+     * A DocxEditor member rather than a compatibility one: the reference's range collection publishes
+     * only its first, and the pieces of a split are the case that makes the other end worth having —
+     * "the paragraph this one ended up as" is the last piece, and counting `items` to find it means
+     * loading them all. Recorded as an omission in `compat/manifest.json` for that reason.
      */
-    getById(id: number): ContentControl;
-    /** Every control in the scope carrying one tag, in document order. */
-    getByTag(tag: string): ContentControlCollection;
-    /** Every control in the scope carrying one title, in document order. */
-    getByTitle(title: string): ContentControlCollection;
+    getLast(): Range;
+    /** The first range, or an object that will report `isNullObject`. */
+    getFirstOrNullObject(): Range;
     /** @internal The read that answers this collection's members. */
-    protected listing(): AutomationOperation;
+    protected listing(): AutomationOperation | null;
+    /** @internal How many members the listing's answer describes. */
+    protected size(value: AutomationValue, label: string): number;
+    /** @internal The address of one member of the listing's answer. */
+    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
     /** @internal Build one member from an address the listing answered. */
-    protected itemAt(label: string, address: ObjectAddress): ContentControl;
+    protected itemAt(label: string, address: ObjectAddress): Range;
     /** @internal A member an edge accessor named before the sync that finds it. */
-    protected promised(label: string, nullable: boolean): ContentControl & PromisedItem;
+    protected promised(label: string, nullable: boolean): Range & PromisedItem;
 }
 
 /** Which kind of note: Word's own two. */
@@ -1146,13 +1672,6 @@ declare class NoteItemCollection extends HandleCollection<NoteItem> {
     protected promised(label: string, nullable: boolean): NoteItem & PromisedItem;
 }
 
-/**
- * Which way round a page is, in Word's own spelling.
- *
- * Capitalised here and lower-case in the engine on purpose: the engine speaks OOXML's vocabulary,
- * and this is the public API's. The mapping lives in this file and nowhere else.
- */
-type PageOrientation = 'Portrait' | 'Landscape';
 /** Which header or footer of a section: Word's own three variants. */
 type HeaderFooterType = 'Primary' | 'FirstPage' | 'EvenPages';
 /**
@@ -1180,8 +1699,8 @@ declare class PageSetup extends ModelObject {
      * Writing it alone SWAPS this section's own dimensions rather than assuming a paper size, so a
      * document of mixed sizes survives a flip with its sizes intact.
      */
-    get orientation(): PageOrientation;
-    set orientation(value: PageOrientation);
+    get orientation(): PageOrientation | 'Portrait' | 'Landscape';
+    set orientation(value: PageOrientation | 'Portrait' | 'Landscape');
     /** Points. */
     get topMargin(): number;
     set topMargin(value: number);
@@ -1232,9 +1751,9 @@ declare class Section extends ModelObject implements PromisedItem {
     get body(): Body;
     /** The page this section is laid out on. */
     get pageSetup(): PageSetup;
-    /** The header story of one variant, as a body. `ItemNotFound` where the document has none. */
+    /** The header story, or a virtual empty body created by its first content insertion. */
     getHeader(type: HeaderFooterType): Body;
-    /** The footer story of one variant, as a body. `ItemNotFound` where the document has none. */
+    /** The footer story, or a virtual empty body created by its first content insertion. */
     getFooter(type: HeaderFooterType): Body;
     /** The next section. `ItemNotFound` at the sync when this is the last one. */
     getNext(): Section;
@@ -1261,8 +1780,6 @@ declare class SectionCollection extends HandleCollection<Section> {
     protected promised(label: string, nullable: boolean): Section & PromisedItem;
 }
 
-/** Office.js tracking mode names. TrackAll is recognized but currently refused. @public */
-type ChangeTrackingMode = 'Off' | 'TrackAll' | 'TrackMineOnly';
 /**
  * The document: the root every other object is reached from.
  *
@@ -1298,14 +1815,15 @@ declare class Document extends ModelObject {
     static open(context: RequestContext): Document;
     private constructor();
     /**
-     * Tracking for this server host. Load 'changeTrackingMode' explicitly before reading.
+     * Tracking for this automation runtime. Load 'changeTrackingMode' explicitly before reading.
      * Document.load() keeps an empty default property set across hosts. Assignments take effect at sync.
      * TrackMineOnly tracks this runtime's inline text edits using its configured author.
-     * TrackAll and browser-host mode control are not supported. Unsupported tracked mutation
+     * TrackAll is unsupported. Browser tracked writes require the review module; this setting
+     * does not change the editor UI mode. Unsupported tracked mutation
      * kinds refuse; the setting is session-local and is not saved as a document-wide policy.
      */
-    get changeTrackingMode(): ChangeTrackingMode;
-    set changeTrackingMode(mode: ChangeTrackingMode);
+    get changeTrackingMode(): ChangeTrackingMode | 'Off' | 'TrackAll' | 'TrackMineOnly';
+    set changeTrackingMode(mode: ChangeTrackingMode | 'Off' | 'TrackAll' | 'TrackMineOnly');
     /**
      * The main story.
      *
@@ -1368,7 +1886,7 @@ interface DocumentCapabilities {
  * Runs are ISOLATED, not serialized. Every {@link DocxEditorRuntime.run} gets its own context and
  * its own queue, so two runs cannot interleave into one batch, and a run started inside another
  * run works instead of waiting for a lock its own caller holds. Batches are still ordered — each
- * `sync()` sends one atomic batch, in the order the `sync()` calls happen.
+ * `sync()` commits writes atomically; read dependencies can use additional read-only batches.
  *
  * Disposal is final: {@link DocxEditorRuntime.dispose} releases the host once and is safe to call
  * again, and every later `run` fails with `RuntimeDisposed`.
@@ -1457,10 +1975,10 @@ interface RuntimeSession {
 /**
  * What a `run` hands its callback: one queue, one document, one sync at a time.
  *
- * `sync()` is the only thing in this runtime that talks to the document, and it does so exactly
- * once per call — plan the queued actions in order, send ONE batch, hydrate the answers. That is
- * where atomicity comes from: the host commits a batch as one transaction, and the runtime never
- * splits a consumer's `sync()` into several batches behind their back.
+ * `sync()` commits all queued commands in one atomic transaction. Supported read-derived
+ * proxy dependencies can require additional read-only transport calls before that commit.
+ * These reads and the final write share one revision; a concurrent change refuses the sync.
+ * Write-created proxies require a separate sync before dependent operations.
  *
  * Conditional writes come from the same place. A context that has READ from the document
  * remembers the revision it read at, and a later batch that writes goes out conditional on it,
@@ -1487,7 +2005,7 @@ declare class RequestContext {
     /** Objects kept addressable past the run that created them. See {@link TrackedObjects}. */
     get trackedObjects(): TrackedObjects;
     /**
-     * Send everything queued as one batch and hydrate the answers.
+     * Resolve read prerequisites, then commit queued writes atomically and hydrate answers.
      *
      * An empty queue is not a round trip. Office-shaped code syncs defensively at the end of a
      * batch, and turning "nothing to say" into a host call would make a no-op sync advance a
@@ -1615,96 +2133,6 @@ interface ResolvedLoadOptions {
     readonly skip?: number;
 }
 
-/**
- * What the host is told to look at.
- *
- * Two shapes, because the protocol names two kinds of thing. Most objects ARE something the host
- * minted a handle for. A stretch of a story is not: it is two endpoints, each a paragraph handle
- * and a UTF-16 offset, and there is no third object behind it to hand out a handle for. Giving a
- * range a handle of its own would mean the host tracking a region across every edit, which is a
- * promise it cannot keep — so the address is the endpoints, and a deleted paragraph makes the
- * whole address refuse rather than silently name a different place.
- */
-type ObjectAddress = {
-    readonly kind: 'handle';
-    readonly handle: AutomationHandle;
-} | {
-    readonly kind: 'span';
-    readonly span: AutomationSpan;
-};
-type ObjectPathState = 
-/** Promised: created by a queued read that has not answered yet. */
-{
-    readonly status: 'pending';
-}
-/** Addressable: the host has named this object, or the span it stands for is known. */
- | {
-    readonly status: 'resolved';
-    readonly address: ObjectAddress;
-}
-/** A `get…OrNullObject` that found nothing. Not an error, and never addressable. */
- | {
-    readonly status: 'null';
-}
-/** Its run ended without tracking it. Terminal. */
- | {
-    readonly status: 'released';
-};
-declare class ObjectPath {
-    #private;
-    readonly label: string;
-    private constructor();
-    /** A path that is addressable from the moment it exists — a root, or an item just hydrated. */
-    static of(label: string, handle: AutomationHandle): ObjectPath;
-    /** The same, for an object that IS a stretch of a story. */
-    static ofSpan(label: string, span: AutomationSpan): ObjectPath;
-    /** A path a queued read will fill in — or mark null. */
-    static pending(label: string): ObjectPath;
-    /** A path that is whatever its owner's path is, under its own name. */
-    static derived(label: string, parent: ObjectPath): ObjectPath;
-    get state(): ObjectPathState;
-    get isAddressable(): boolean;
-    get isPending(): boolean;
-    get isNull(): boolean;
-    get isReleased(): boolean;
-    /**
-     * What to put in a batch, or a refusal.
-     *
-     * Both refusals are `InvalidObjectPath` on purpose: from a consumer's side "this object was
-     * released" and "this object is still a promise" are the same mistake — using an object the
-     * runtime cannot address yet or any more — and the `target` says which object it was.
-     *
-     * THE CODE IS ONE THING AND THE MESSAGE IS ANOTHER. The two states have different fixes — a
-     * promise needs a `sync()`, a released object needs to have been tracked — so the sentence in
-     * `errors.ts` names both. It described only the released half for a while, which sent a
-     * consumer holding a perfectly good promised object off to `trackedObjects.add(...)`.
-     */
-    address(): ObjectAddress;
-    /** The handle to address this object with. Refused for anything that is not handle-shaped. */
-    handle(): AutomationHandle;
-    /** The span this object stands for. Refused for anything that is not span-shaped. */
-    span(): AutomationSpan;
-    /**
-     * Hydration: the read answered, and this is the object it named.
-     *
-     * A released path stays released. Hydration arriving for one is not an error — a batch can be
-     * in flight when a run ends — but resurrecting the object would hand back a proxy whose
-     * lifetime rules had already been applied.
-     */
-    resolveTo(handle: AutomationHandle): void;
-    /** The same, for an object that came back as a stretch of a story. */
-    resolveToSpan(span: AutomationSpan): void;
-    /** Hydration: the read answered, and there was nothing there. */
-    resolveNull(): void;
-    /**
-     * The run ended and nothing kept this object alive. Terminal.
-     *
-     * A derived path does not release: its owner's release is what governs it, and releasing here
-     * would let a collection's lifetime end its parent's.
-     */
-    release(): void;
-}
-
 /**
  * The base every document proxy extends.
  *
@@ -1764,6 +2192,8 @@ declare abstract class ClientObject implements RuntimeManagedObject {
      * perfectly good and only needs adopting, which is what `InvalidRequestContext` says.
      */
     protected requireAddressable(): void;
+    /** Permit queued read dependencies and optional scalar loads; refuse released proxies. */
+    protected requireUsablePath(): void;
     /** @internal Add one action to the context's queue, to be planned at the next sync. */
     protected enqueue(action: QueuedAction): void;
     /** @internal Read a property a completed `load` filled in; refuses if none did. */
@@ -1787,12 +2217,8 @@ declare abstract class ClientObject implements RuntimeManagedObject {
  * sync fills it, and reading it early is `ValueNotLoaded` rather than `undefined` flowing onwards
  * into something that misinterprets it.
  *
- * @example
- * ```ts
- * const count = body.getParagraphCount();
- * await context.sync();
- * console.log(count.value);
- * ```
+ * This is a support type. No current public document method produces a ClientResult.
+ * Document collections expose loaded `items`; read their length after `load('items')` and `sync()`.
  *
  * @public
  */
@@ -1935,6 +2361,43 @@ declare class DocxEditorError extends Error {
  */
 declare function isDocxEditorError(value: unknown): value is DocxEditorError;
 
+/** An inert Word field. Code writes and evaluation support PAGE and NUMPAGES. @public */
+declare class Field extends ModelObject implements PromisedItem {
+    #private;
+    /** @internal */
+    static at(context: RequestContext, label: string, address: ObjectAddress): Field;
+    /** @internal */
+    static promised(context: RequestContext, label: string, nullable: boolean): Field;
+    private constructor();
+    /** @internal */
+    hydrateAddress(address: ObjectAddress): void;
+    /** @internal */
+    hydrateNull(): void;
+    get code(): string;
+    set code(value: string);
+    /** Remove this field, including its cached result. Other fields remain inert and unchanged. */
+    delete(): void;
+    /** Compute a cached result using actual host pagination. Missing pagination refuses explicitly. */
+    updateResult(): void;
+    protected onLoad(request: ResolvedLoadOptions): void;
+}
+/** Fields contained within a body or range. @public */
+declare class FieldCollection extends ItemCollection<Field> {
+    #private;
+    /** @internal */
+    static of(context: RequestContext, label: string, owner: ObjectPath, kind: SpanOwner): FieldCollection;
+    private constructor();
+    getFirst(): Field;
+    getLast(): Field;
+    getFirstOrNullObject(): Field;
+    getLastOrNullObject(): Field;
+    protected listing(): AutomationOperation;
+    protected size(value: AutomationValue, label: string): number;
+    protected addressAt(value: AutomationValue, label: string, index: number): ObjectAddress | undefined;
+    protected itemAt(label: string, address: ObjectAddress): Field;
+    protected promised(label: string, nullable: boolean): Field & PromisedItem;
+}
+
 /**
  * A story: the main body of a document, a header or footer variant, or a note's body — and
  * everything in it in reading order.
@@ -2023,16 +2486,28 @@ declare class Body extends ModelObject {
      * resolve every store-resolvable revision in this story.
      */
     get revisions(): RevisionCollection;
+    /** The whole body or one edge. Await sync before addressing the returned range. */
+    getRange(rangeLocation?: 'Whole' | 'Content' | 'Start' | 'End' | 'Before' | 'After'): Range;
     /** Every occurrence of `searchText` in this story, as ranges, in reading order. */
     search(searchText: string, options?: SearchOptions): RangeCollection;
     /** Empty the story, leaving one empty paragraph behind. */
     clear(): void;
     /** Write text over the whole story, or at either edge of it. Answers the text's own range. */
-    insertText(text: string, insertLocation: 'Replace' | 'Start' | 'End'): Range;
+    insertText(text: string, insertLocation: InsertLocation.replace | InsertLocation.start | InsertLocation.end | 'Replace' | 'Start' | 'End'): Range;
     /** Add a paragraph at the start or the end of the story. Answers the new paragraph. */
-    insertParagraph(paragraphText: string, insertLocation: 'Start' | 'End'): Paragraph;
+    insertParagraph(paragraphText: string, insertLocation: InsertLocation.start | InsertLocation.end | 'Start' | 'End'): Paragraph;
     /** @internal Plan the read this object's `load(...)` asked for. */
     protected onLoad(request: ResolvedLoadOptions): void;
+    /** Fields within this body. */
+    get fields(): FieldCollection;
+    /** Inline pictures within this body. */
+    get inlinePictures(): InlinePictureCollection;
+    /** Top-level tables within this body or table cell. */
+    get tables(): TableCollection;
+}
+
+/** Explicit measurement inputs for headless field calculation. @public */
+interface ServerPaginationOptions extends AutomationPaginationOptions {
 }
 
 /**
@@ -2089,6 +2564,8 @@ interface DocumentLimits {
  * @public
  */
 interface CreateServerOptions {
+    /** Font-aware pagination required to calculate PAGE/NUMPAGES fields headlessly. */
+    readonly pagination?: ServerPaginationOptions;
     /**
      * Capability modules to register. Collaboration attaches only through a
      * collaboration contribution on this list.
@@ -2120,4 +2597,4 @@ interface CreateServerOptions {
 /** Options for {@link createCollaborative}. @public */
 type CreateCollaborativeOptions = CreateServerOptions;
 
-export { RevisionCollection as $, type DocxEditorRuntime as A, type BesideLocation as B, type CreateServerOptions as C, type DocxEditorServerRuntime as D, type EditorModule as E, Font as F, ListCollection as G, type HeaderFooterType as H, type InsertLocation as I, ListItem as J, type LoadOption as K, List as L, type LoadQueryOptions as M, NoteItem as N, NoteItemCollection as O, type NoteItemType as P, type PageOrientation as Q, PageSetup as R, Paragraph as S, type ParagraphAlignment as T, ParagraphCollection as U, type ParagraphInsertTextLocation as V, Range as W, RangeCollection as X, type RangeInsertTextLocation as Y, RequestContext as Z, Revision as _, type CreateCollaborativeOptions as a, type RevisionTextView as a0, type RevisionType as a1, type RunCallback as a2, type SearchOptions as a3, Section as a4, SectionCollection as a5, type SelectionMode as a6, TrackedObjects as a7, isDocxEditorError as a8, Body as b, type BodyInsertParagraphLocation as c, type BodyInsertTextLocation as d, Bookmark as e, BookmarkCollection as f, type ChangeTrackingMode as g, ClientObject as h, ClientResult as i, Comment as j, CommentCollection as k, CommentReply as l, CommentReplyCollection as m, ContentControl as n, ContentControlCollection as o, type ContentControlLockState as p, type ContentControlSubtype as q, type ContentControlValue as r, Document as s, type DocumentCapabilities as t, type DocumentLimits as u, type DocumentXmlLimits as v, type DocumentZipLimits as w, DocxEditorError as x, type DocxEditorErrorCode as y, type DocxEditorErrorInit as z };
+export { PageOrientation as $, Alignment as A, type BesideLocation as B, type CreateServerOptions as C, type DocxEditorServerRuntime as D, type DocxEditorErrorCode as E, type DocxEditorErrorInit as F, type DocxEditorRuntime as G, type EditorModule as H, Field as I, FieldCollection as J, FieldType as K, type FieldTypeLiteral as L, Font as M, type HeaderFooterType as N, InlinePicture as O, InlinePictureCollection as P, InsertLocation as Q, List as R, ListBullet as S, ListCollection as T, ListItem as U, ListNumbering as V, type LoadOption as W, type LoadQueryOptions as X, NoteItem as Y, NoteItemCollection as Z, type NoteItemType as _, type CreateCollaborativeOptions as a, PageSetup as a0, Paragraph as a1, type ParagraphAlignment as a2, ParagraphCollection as a3, type ParagraphInsertTextLocation as a4, Range as a5, RangeCollection as a6, type RangeInsertTextLocation as a7, RequestContext as a8, Revision as a9, RevisionCollection as aa, type RevisionTextView as ab, type RevisionType as ac, type RunCallback as ad, type SearchOptions as ae, Section as af, SectionCollection as ag, type SelectionMode as ah, type ServerPaginationOptions as ai, Table as aj, TableCell as ak, TableCellCollection as al, TableCollection as am, TableRow as an, TableRowCollection as ao, TrackedObjects as ap, UnderlineType as aq, VerticalAlignment as ar, isDocxEditorError as as, Body as b, type BodyInsertParagraphLocation as c, type BodyInsertTextLocation as d, Bookmark as e, BookmarkCollection as f, BreakType as g, ChangeTrackingMode as h, ClientObject as i, ClientResult as j, Comment as k, CommentCollection as l, CommentReply as m, CommentReplyCollection as n, ContentControl as o, ContentControlCollection as p, type ContentControlLockState as q, type ContentControlSubtype as r, ContentControlType as s, type ContentControlValue as t, Document as u, type DocumentCapabilities as v, type DocumentLimits as w, type DocumentXmlLimits as x, type DocumentZipLimits as y, DocxEditorError as z };