@coco-vexel/coco-office-editor 0.0.0-stage → 1.0.0

package/dist/native-Ct9nN06K.d.cts

@@ -0,0 +1,1111 @@
+import { p as EditorParagraphFormat, v as EditorRunFormat, t as EditorRevisionSegment, j as EditorHyperlink, k as EditorImageSegment, f as EditorDrawingSegment, g as EditorFieldSegment, I as EditorTableView, C as EditorTableBorders, D as EditorTableCellView, d as EditorDocumentDefaults, m as EditorPageLayout, e as EditorDocumentView, i as EditorHeaderFooterStoryView, l as EditorNumberingFormat } from './model-DB6aN6uJ.cjs';
+import { Package } from '@coco-vexel/coco-office/pack';
+import { PackageIndices } from '@coco-vexel/coco-office/word-view';
+
+interface NativeWordTextNode {
+    kind: 'text';
+    text: string;
+    format: EditorRunFormat | null;
+    marks?: NativeWordTextMark[];
+    formatRevision?: NativeWordFormatRevisionMark;
+    hyperlink?: EditorHyperlink;
+}
+type NativeWordTextMark = NativeWordCommentMark | NativeWordRevisionMark;
+interface NativeWordFormatRevisionMark {
+    kind: 'format';
+    revisionId: string;
+    beforeFormat: EditorRunFormat | null;
+    author?: string;
+    date?: string;
+}
+interface NativeWordCommentMark {
+    kind: 'comment';
+    id: string;
+    commentId: number;
+    parentCommentId?: number;
+    author: string;
+    date: string;
+    body: string;
+}
+interface NativeWordRevisionMark {
+    kind: 'revision';
+    id: string;
+    revisionId: string;
+    revisionKind: EditorRevisionSegment['revisionKind'];
+    author?: string;
+    date?: string;
+}
+interface NativeWordImageNode {
+    kind: 'image';
+    drawingId: string;
+    src: string;
+    revision?: NativeWordRevisionMark;
+    formatRevision?: {
+        kind: 'format';
+        revisionId: string;
+        beforeWidth?: number;
+        beforeHeight?: number;
+        afterWidth?: number;
+        afterHeight?: number;
+        author?: string;
+        date?: string;
+    };
+    width?: number;
+    height?: number;
+    anchoringMode?: EditorImageSegment['anchoringMode'];
+    wrap?: EditorImageSegment['wrap'];
+    position?: EditorImageSegment['position'];
+}
+interface NativeWordDrawingNode {
+    kind: 'drawing';
+    drawingId: string;
+    drawingKind: EditorDrawingSegment['drawingKind'];
+    text?: string;
+    width?: number;
+    height?: number;
+    anchoringMode?: EditorDrawingSegment['anchoringMode'];
+    wrap?: EditorDrawingSegment['wrap'];
+    position?: EditorDrawingSegment['position'];
+    hasBorder?: boolean;
+    hasFill?: boolean;
+    isLineOrConnector?: boolean;
+    innerTextAlign?: string;
+    paragraphs?: NativeWordParagraphNode[];
+}
+interface NativeWordPageBreakNode {
+    kind: 'pageBreak';
+}
+interface NativeWordFieldNode {
+    kind: 'field';
+    fieldKind: EditorFieldSegment['fieldKind'];
+    instruction: string;
+    cachedText?: string;
+    format: EditorRunFormat | null;
+}
+type NativeWordInlineNode = NativeWordTextNode | NativeWordImageNode | NativeWordDrawingNode | NativeWordFieldNode | NativeWordPageBreakNode;
+interface NativeWordParagraphNode {
+    kind: 'paragraph';
+    paraId: string;
+    story: string;
+    styleId: string | null;
+    format: EditorParagraphFormat | null;
+    content: NativeWordInlineNode[];
+}
+interface NativeWordTableNode {
+    kind: 'table';
+    tableId: string;
+    revision?: NativeWordRevisionMark;
+    tableStyleId?: string;
+    columnWidths: number[];
+    layout?: EditorTableView['layout'];
+    borders?: EditorTableBorders;
+    rows: NativeWordTableRowNode[];
+}
+interface NativeWordTableRowNode {
+    height?: {
+        val: number;
+        hRule: 'auto' | 'atLeast' | 'exact';
+    };
+    isHeader?: boolean;
+    cantSplit?: boolean;
+    cells: NativeWordTableCellNode[];
+}
+interface NativeWordTableCellNode {
+    blocks: NativeWordBlockNode[];
+    paragraphs: NativeWordParagraphNode[];
+    gridSpan: number;
+    rowSpan?: number;
+    vMerge?: EditorTableCellView['vMerge'];
+    width?: number;
+    margin?: EditorTableCellView['margin'];
+    borders?: EditorTableCellView['borders'];
+    shading?: EditorTableCellView['shading'];
+    verticalAlignment?: EditorTableCellView['verticalAlignment'];
+    noWrap?: EditorTableCellView['noWrap'];
+}
+type NativeWordBlockNode = NativeWordParagraphNode | NativeWordTableNode;
+interface NativeWordDocument {
+    kind: 'word';
+    defaults?: EditorDocumentDefaults;
+    pageLayout?: EditorPageLayout;
+    sections: EditorDocumentView['sections'];
+    headers: NativeWordHeaderFooterStory[];
+    footers: NativeWordHeaderFooterStory[];
+    blocks: NativeWordBlockNode[];
+}
+interface NativeWordHeaderFooterStory {
+    kind: EditorHeaderFooterStoryView['kind'];
+    partName: string;
+    blocks: NativeWordBlockNode[];
+}
+interface NativeParagraphLocation {
+    paragraph: NativeWordParagraphNode;
+    previous: NativeWordParagraphNode | null;
+    container: NativeWordBlockNode[];
+    index: number;
+    insertAfter(paragraph: NativeWordParagraphNode): void;
+    remove(): void;
+}
+interface NativeTableCellLocation {
+    table: NativeWordTableNode;
+    container: NativeWordBlockNode[];
+    tableIndex: number;
+    row: NativeWordTableRowNode;
+    rowIndex: number;
+    cell: NativeWordTableCellNode;
+    cellIndex: number;
+    columnIndex: number;
+}
+interface NativeTableLocation {
+    table: NativeWordTableNode;
+    container: NativeWordBlockNode[];
+    tableIndex: number;
+}
+declare function createNativeWordDocument(view: EditorDocumentView): NativeWordDocument;
+declare function findNativeParagraph(doc: NativeWordDocument, paraId: string): NativeWordParagraphNode | null;
+declare function previousNativeParagraphId(doc: NativeWordDocument, paraId: string): string | null;
+declare function findNativeParagraphLocation(doc: NativeWordDocument, paraId: string): NativeParagraphLocation | null;
+declare function findNativeTableCellLocation(doc: NativeWordDocument, paraId: string): NativeTableCellLocation | null;
+declare function findNativeTableLocation(doc: NativeWordDocument, tableId: string): NativeTableLocation | null;
+declare function allNativeParagraphs(doc: NativeWordDocument): NativeWordParagraphNode[];
+declare function nativeParagraphText(paragraph: NativeWordParagraphNode): string;
+declare function createNativeParaId(doc: NativeWordDocument): string;
+
+type NativeWordChange = {
+    kind: 'text';
+    op: 'insert' | 'delete' | 'replace';
+    paraId: string;
+    offset: number;
+    text: string;
+    deletedText?: string;
+} | {
+    kind: 'block';
+    op: 'split' | 'merge';
+    paraId: string;
+    newParaId?: string;
+    offset?: number;
+} | {
+    kind: 'structure';
+    op: 'delete-range';
+    startParaId: string;
+    endParaId: string;
+    deletedBlockIds: string[];
+} | {
+    kind: 'structure';
+    op: 'insert-range';
+    paraId: string;
+    insertedBlockIds: string[];
+} | {
+    kind: 'image';
+    op: 'insert' | 'delete' | 'resize' | 'accept' | 'reject';
+    paraId: string;
+    offset: number;
+    drawingId: string;
+    src?: string;
+    width?: number;
+    height?: number;
+    revisionId?: string;
+    revisionKind?: 'insert' | 'delete' | 'format';
+} | {
+    kind: 'format';
+    op: 'run' | 'accept' | 'reject';
+    paraId: string;
+    from: number;
+    to: number;
+    format: Partial<EditorRunFormat>;
+    clear?: boolean;
+    revisionId?: string;
+    revisionKind?: 'format';
+    beforeFormat?: Partial<EditorRunFormat> | null;
+} | {
+    kind: 'format';
+    op: 'paragraph';
+    paraId: string;
+    format: Partial<EditorParagraphFormat>;
+} | {
+    kind: 'list';
+    paraId: string;
+    numbering: EditorNumberingFormat | null;
+} | {
+    kind: 'hyperlink';
+    op: 'set' | 'remove';
+    paraId: string;
+    from: number;
+    to: number;
+    hyperlink?: EditorHyperlink;
+} | {
+    kind: 'annotation';
+    op: 'insert' | 'delete' | 'update';
+    paraId: string;
+    from: number;
+    to: number;
+    commentId: number;
+    body?: string;
+    parentCommentId?: number;
+} | {
+    kind: 'revision';
+    op: 'insert' | 'delete' | 'accept' | 'reject';
+    paraId: string;
+    from: number;
+    to: number;
+    revisionId: string;
+    revisionKind: 'insert' | 'delete';
+} | {
+    kind: 'page-break';
+    op: 'insert' | 'delete';
+    paraId: string;
+    offset: number;
+} | {
+    kind: 'table';
+    op: 'insert-table' | 'delete-table' | 'insert-row' | 'delete-row' | 'insert-column' | 'delete-column' | 'merge-cells' | 'split-cell' | 'format-cell' | 'clear-cell' | 'replace-cell';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+    endColumnIndex?: number;
+    endRowIndex?: number;
+    format?: {
+        backgroundColor?: string | null;
+        verticalAlignment?: NativeWordTableCellNode['verticalAlignment'] | null;
+        borderColor?: string | null;
+    };
+    text?: string;
+    cellSnapshot?: NativeWordTableCellNode;
+    revisionId?: string;
+    revisionKind?: 'insert' | 'delete';
+    revisionAction?: 'accept' | 'reject';
+    beforeTable?: NativeWordTableNode;
+    anchorParaId?: string;
+    anchorOffset?: number;
+    tableSnapshot?: NativeWordTableNode;
+};
+interface NativePlainTextReplacement {
+    changes: NativeWordChange[];
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+    paragraphIds: string[];
+}
+interface NativeBlockRangeReplacement {
+    changes: NativeWordChange[];
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+    container: NativeWordBlockNode[];
+    startIndex: number;
+    beforeBlocks: NativeWordBlockNode[];
+    afterBlocks: NativeWordBlockNode[];
+}
+interface NativeTableEditResult {
+    change: NativeWordChange;
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+}
+interface NativeTableCellPoint {
+    rowIndex: number;
+    columnIndex: number;
+}
+interface NativeTableCellRange {
+    anchor: NativeTableCellPoint;
+    focus: NativeTableCellPoint;
+}
+interface NativeTableRangeEditResult {
+    changes: NativeWordChange[];
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+}
+interface NativeTableClipboardCell {
+    blocks: NativeWordBlockNode[];
+    format: {
+        margin?: NativeWordTableCellNode['margin'];
+        borders?: NativeWordTableCellNode['borders'];
+        shading?: NativeWordTableCellNode['shading'];
+        verticalAlignment?: NativeWordTableCellNode['verticalAlignment'];
+        noWrap?: NativeWordTableCellNode['noWrap'];
+    };
+}
+type NativeTableStructureOperation = {
+    kind: 'insert-row';
+    position: 'before' | 'after';
+} | {
+    kind: 'delete-row';
+} | {
+    kind: 'insert-column';
+    position: 'before' | 'after';
+} | {
+    kind: 'delete-column';
+};
+interface NativeTableCellFormatPatch {
+    backgroundColor?: string | null;
+    verticalAlignment?: NativeWordTableCellNode['verticalAlignment'] | null;
+    borderColor?: string | null;
+}
+declare function cloneNativeWordBlocks(blocks: readonly NativeWordBlockNode[]): NativeWordBlockNode[];
+declare function nativeTableSupportsStructuralEditing(table: NativeWordTableNode): boolean;
+declare function nativeInsertTable(doc: NativeWordDocument, paraId: string, offset: number, rowCount: number, columnCount: number, createParaId?: () => string, createTableId?: () => string): NativeBlockRangeReplacement | null;
+declare function nativeDeleteTable(doc: NativeWordDocument, tableId: string, createParaId?: () => string): NativeBlockRangeReplacement | null;
+declare function nativeEditTableStructure(doc: NativeWordDocument, paraId: string, operation: NativeTableStructureOperation, createParaId?: () => string): NativeTableEditResult | null;
+declare function nativeSetTableCellFormat(doc: NativeWordDocument, paraId: string, patch: NativeTableCellFormatPatch): NativeTableEditResult | null;
+declare function nativeTableCellsInRange(table: NativeWordTableNode, range: NativeTableCellRange): Array<{
+    cell: NativeWordTableCellNode;
+    rowIndex: number;
+    columnIndex: number;
+}>;
+declare function nativeMergeTableCells(doc: NativeWordDocument, tableId: string, range: NativeTableCellRange): {
+    change: NativeWordChange;
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+} | null;
+declare function nativeSplitTableCell(doc: NativeWordDocument, tableId: string, rowIndex: number, columnIndex: number, createParaId?: () => string): {
+    change: NativeWordChange;
+    cursor: {
+        paraId: string;
+        offset: number;
+    };
+} | null;
+declare function nativeSetTableCellRangeFormat(doc: NativeWordDocument, tableId: string, range: NativeTableCellRange, patch: NativeTableCellFormatPatch): NativeTableRangeEditResult | null;
+declare function nativeClearTableCellRange(doc: NativeWordDocument, tableId: string, range: NativeTableCellRange): NativeTableRangeEditResult | null;
+declare function nativeReplaceTableCellRangeText(doc: NativeWordDocument, tableId: string, anchor: NativeTableCellPoint, values: readonly (readonly string[])[]): NativeTableRangeEditResult | null;
+declare function nativeReplaceTableCellRangeContent(doc: NativeWordDocument, tableId: string, anchor: NativeTableCellPoint, values: readonly (readonly (NativeTableClipboardCell | null)[])[]): NativeTableRangeEditResult | null;
+declare function nativeInsertText(doc: NativeWordDocument, paraId: string, offset: number, text: string): NativeWordChange | null;
+declare function nativeInsertImage(doc: NativeWordDocument, paraId: string, offset: number, src: string, options?: {
+    drawingId?: string;
+    width?: number;
+    height?: number;
+}): NativeWordChange | null;
+declare function nativeInsertPageBreak(doc: NativeWordDocument, paraId: string, offset: number): NativeWordChange | null;
+declare function nativePageBreakAt(doc: NativeWordDocument, paraId: string, offset: number): boolean;
+declare function nativeRangeContainsPageBreak(doc: NativeWordDocument, paraId: string, from: number, to: number): boolean;
+declare function nativeSetImageSize(doc: NativeWordDocument, paraId: string, drawingId: string, size: {
+    width: number;
+    height: number;
+}): NativeWordChange | null;
+declare function nativeDeleteBackward(doc: NativeWordDocument, paraId: string, offset: number): NativeWordChange | null;
+declare function nativeDeleteForward(doc: NativeWordDocument, paraId: string, offset: number): NativeWordChange | null;
+declare function nativeDeleteRange(doc: NativeWordDocument, paraId: string, from: number, to: number): NativeWordChange[];
+declare function nativeDeleteTextRangeAcrossParagraphs(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}): NativeWordChange[];
+declare function nativeReplaceBlockRangeAcrossParagraphs(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}, text: string): NativeBlockRangeReplacement | null;
+declare function nativeCopyBlockRange(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}): NativeWordBlockNode[] | null;
+declare function nativeReplaceRangeWithBlocks(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}, clipboardBlocks: readonly NativeWordBlockNode[]): NativeBlockRangeReplacement | null;
+declare function nativeReplaceRange(doc: NativeWordDocument, paraId: string, from: number, to: number, text: string): NativeWordChange[];
+declare function nativeReplaceTextRangeAcrossParagraphs(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}, text: string): NativeWordChange[];
+declare function nativeReplaceTextRangeWithParagraphs(doc: NativeWordDocument, anchor: {
+    paraId: string;
+    offset: number;
+}, focus: {
+    paraId: string;
+    offset: number;
+}, text: string): NativePlainTextReplacement | null;
+declare function nativeSetRunFormat(doc: NativeWordDocument, paraId: string, from: number, to: number, format: Partial<EditorRunFormat>): NativeWordChange | null;
+declare function nativeAddComment(doc: NativeWordDocument, paraId: string, from: number, to: number, comment: {
+    commentId: number;
+    author: string;
+    date: string;
+    body: string;
+    parentCommentId?: number;
+    preserveExistingComments?: boolean;
+}): NativeWordChange | null;
+declare function nativeUpdateComment(doc: NativeWordDocument, commentId: number, body: string): NativeWordChange[];
+declare function nativeDeleteComment(doc: NativeWordDocument, commentId: number): NativeWordChange[];
+declare function nativeAddRevision(doc: NativeWordDocument, paraId: string, from: number, to: number, revision: {
+    revisionId: string;
+    revisionKind: 'insert' | 'delete';
+    author: string;
+    date: string;
+}): NativeWordChange | null;
+declare function nativeResolveRevision(doc: NativeWordDocument, paraId: string, from: number, to: number, operation: 'accept' | 'reject'): NativeWordChange | null;
+declare function nativeResolveFormatRevision(doc: NativeWordDocument, paraId: string, from: number, to: number, operation: 'accept' | 'reject'): NativeWordChange | null;
+declare function nativeSetHyperlink(doc: NativeWordDocument, paraId: string, from: number, to: number, hyperlink: EditorHyperlink | null): NativeWordChange | null;
+declare function nativeSetParagraphFormat(doc: NativeWordDocument, paraId: string, format: Partial<EditorParagraphFormat>): NativeWordChange | null;
+declare function nativeClearRunFormat(doc: NativeWordDocument, paraId: string, from: number, to: number): NativeWordChange | null;
+declare function nativeSetParagraphList(doc: NativeWordDocument, paraId: string, numbering: EditorNumberingFormat | null): NativeWordChange | null;
+declare function nativeTextRangeIsBold(doc: NativeWordDocument, paraId: string, from: number, to: number): boolean;
+declare function nativeDeleteImage(doc: NativeWordDocument, paraId: string, drawingId: string): NativeWordChange | null;
+declare function nativeAddFormatRevision(doc: NativeWordDocument, paraId: string, from: number, to: number, beforeParagraph: NativeWordParagraphNode, revision: {
+    revisionId: string;
+    author?: string;
+    date?: string;
+}): NativeWordChange | null;
+declare function nativeResolveImageRevision(doc: NativeWordDocument, paraId: string, drawingId: string, operation: 'accept' | 'reject'): NativeWordChange | null;
+declare function nativeResolveImageFormatRevision(doc: NativeWordDocument, paraId: string, drawingId: string, operation: 'accept' | 'reject'): NativeWordChange | null;
+declare function nativeSplitParagraph(doc: NativeWordDocument, paraId: string, offset: number, newParaId?: string): NativeWordChange | null;
+declare function nativeSyncParagraphText(doc: NativeWordDocument, paraId: string, nextText: string): NativeWordChange | null;
+
+type WordEditorEngineKind = 'native-word';
+type WordEditorSelection = {
+    kind: 'caret';
+    paraId: string;
+    offset: number;
+} | {
+    kind: 'text-range';
+    anchor: WordEditorSelectionPoint;
+    focus: WordEditorSelectionPoint;
+} | {
+    kind: 'object';
+    paraId: string;
+    objectKind: 'image';
+    objectId: string;
+    offset: number;
+} | {
+    kind: 'table-cell-range';
+    tableId: string;
+    anchor: WordEditorTableCellPoint;
+    focus: WordEditorTableCellPoint;
+};
+interface WordEditorSelectionPoint {
+    paraId: string;
+    offset: number;
+}
+interface WordEditorTableCellPoint {
+    rowIndex: number;
+    columnIndex: number;
+}
+interface WordEditorSearchOptions {
+    query: string;
+    matchCase?: boolean;
+    wholeWord?: boolean;
+}
+interface WordEditorSearchMatch {
+    id: string;
+    paraId: string;
+    from: number;
+    to: number;
+    text: string;
+}
+interface WordEditorSearchState {
+    options: WordEditorSearchOptions;
+    matches: readonly WordEditorSearchMatch[];
+    activeIndex: number;
+}
+interface WordEditorHyperlink {
+    target?: string;
+    anchor?: string;
+    tooltip?: string;
+}
+type WordEditorFormatValue<T> = T | 'mixed' | null;
+interface WordEditorLineSpacingState {
+    line: number;
+    lineRule: 'auto' | 'exact' | 'atLeast';
+}
+interface WordEditorCommandState {
+    selectionKind: WordEditorSelection['kind'] | null;
+    trackRevisions: boolean;
+    bold: boolean | 'mixed';
+    italic: boolean | 'mixed';
+    underline: boolean | 'mixed';
+    strike: boolean | 'mixed';
+    fontFamily: WordEditorFormatValue<string>;
+    fontSize: WordEditorFormatValue<number>;
+    textColor: WordEditorFormatValue<string>;
+    highlightColor: WordEditorFormatValue<string>;
+    hyperlink: WordEditorFormatValue<WordEditorHyperlink>;
+    paragraphAlignment: WordEditorFormatValue<'left' | 'center' | 'right' | 'both'>;
+    leftIndent: number | 'mixed';
+    rightIndent: number | 'mixed';
+    firstLineIndent: number | 'mixed';
+    spacingBefore: number | 'mixed';
+    spacingAfter: number | 'mixed';
+    lineSpacing: WordEditorFormatValue<WordEditorLineSpacingState>;
+    listType: WordEditorFormatValue<'bullet' | 'numbered'>;
+    listLevel: WordEditorFormatValue<number>;
+    image: WordEditorImageState | null;
+    table: WordEditorTableState | null;
+}
+interface WordEditorImageState {
+    objectId: string;
+    width: number | null;
+    height: number | null;
+    alignment: 'left' | 'center' | 'right' | 'both' | null;
+}
+interface WordEditorImageInsertOptions {
+    width?: number;
+    height?: number;
+}
+interface WordEditorTableState {
+    tableId: string;
+    rowIndex: number;
+    rowCount: number;
+    columnIndex: number;
+    columnCount: number;
+    range: {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+        cellCount: number;
+    } | null;
+    structuralEditingSupported: boolean;
+    backgroundColor: WordEditorFormatValue<string>;
+    verticalAlignment: WordEditorFormatValue<'top' | 'center' | 'bottom' | 'both'>;
+    borderColor: WordEditorFormatValue<string>;
+    bordersVisible: boolean | 'mixed';
+}
+type WordEditorRuntimeEvent = 'change' | 'selectionChange';
+interface WordEditorChangeEvent {
+    readonly revision: number;
+    readonly changes: readonly NativeWordChange[];
+    readonly revertedChanges: readonly NativeWordChange[];
+    readonly totalChangeCount: number;
+}
+interface WordEditorSelectionChangeEvent {
+    readonly selection: WordEditorSelection | null;
+    readonly commandState: WordEditorCommandState;
+}
+interface WordEditorRuntimeEventMap {
+    change: WordEditorChangeEvent;
+    selectionChange: WordEditorSelectionChangeEvent;
+}
+type WordEditorCommand = {
+    kind: 'insert-text';
+    text: string;
+} | {
+    kind: 'delete-backward';
+} | {
+    kind: 'delete-forward';
+} | {
+    kind: 'delete-range';
+    anchor: WordEditorSelectionPoint;
+    focus: WordEditorSelectionPoint;
+} | {
+    kind: 'replace-range';
+    anchor: WordEditorSelectionPoint;
+    focus: WordEditorSelectionPoint;
+    text: string;
+} | {
+    kind: 'split-paragraph';
+} | {
+    kind: 'insert-page-break';
+} | {
+    kind: 'delete-object';
+    objectKind: 'image';
+    objectId: string;
+} | {
+    kind: 'insert-image';
+    src: string;
+    width?: number;
+    height?: number;
+} | {
+    kind: 'set-image-size';
+    objectId: string;
+    width: number;
+    height: number;
+} | {
+    kind: 'set-image-alignment';
+    objectId: string;
+    alignment: 'left' | 'center' | 'right';
+} | {
+    kind: 'insert-table-row';
+    position: 'before' | 'after';
+} | {
+    kind: 'insert-table';
+    rows: number;
+    columns: number;
+} | {
+    kind: 'delete-table';
+} | {
+    kind: 'delete-table-row';
+} | {
+    kind: 'insert-table-column';
+    position: 'before' | 'after';
+} | {
+    kind: 'delete-table-column';
+} | {
+    kind: 'merge-table-cells';
+} | {
+    kind: 'split-table-cell';
+} | {
+    kind: 'set-table-cell-background';
+    color: string | null;
+} | {
+    kind: 'set-table-cell-vertical-alignment';
+    alignment: 'top' | 'center' | 'bottom' | null;
+} | {
+    kind: 'set-table-cell-borders';
+    color: string | null;
+} | {
+    kind: 'clear-table-cells';
+} | {
+    kind: 'set-hyperlink';
+    hyperlink: WordEditorHyperlink;
+} | {
+    kind: 'remove-hyperlink';
+} | {
+    kind: 'add-comment';
+    body: string;
+    author?: string;
+    date?: string;
+} | {
+    kind: 'edit-comment';
+    commentId: number;
+    body: string;
+} | {
+    kind: 'delete-comment';
+    commentId: number;
+} | {
+    kind: 'reply-comment';
+    commentId: number;
+    body: string;
+} | {
+    kind: 'add-revision';
+    revisionKind: 'insert' | 'delete';
+    author?: string;
+    date?: string;
+} | {
+    kind: 'toggle-track-revisions';
+} | {
+    kind: 'accept-revision';
+    revisionId?: string;
+    revisionKind?: 'insert' | 'delete' | 'format';
+} | {
+    kind: 'reject-revision';
+    revisionId?: string;
+    revisionKind?: 'insert' | 'delete' | 'format';
+} | {
+    kind: 'accept-all-revisions' | 'reject-all-revisions';
+} | {
+    kind: 'toggle-bold';
+} | {
+    kind: 'toggle-italic';
+} | {
+    kind: 'toggle-underline';
+} | {
+    kind: 'toggle-strike';
+} | {
+    kind: 'set-font-family';
+    fontFamily: string;
+} | {
+    kind: 'set-font-size';
+    fontSize: number;
+} | {
+    kind: 'set-text-color';
+    color: string;
+} | {
+    kind: 'set-highlight-color';
+    color: string | null;
+} | {
+    kind: 'clear-text-format';
+} | {
+    kind: 'set-paragraph-alignment';
+    alignment: 'left' | 'center' | 'right' | 'both';
+} | {
+    kind: 'set-paragraph-indent';
+    indent: {
+        left?: number;
+        right?: number;
+        firstLine?: number;
+    };
+} | {
+    kind: 'adjust-paragraph-left-indent';
+    delta: number;
+} | {
+    kind: 'set-paragraph-spacing';
+    spacing: {
+        before?: number;
+        after?: number;
+    };
+} | {
+    kind: 'set-paragraph-line-spacing';
+    line: number;
+    lineRule: 'auto' | 'exact' | 'atLeast';
+} | {
+    kind: 'toggle-list';
+    listType: 'bullet' | 'numbered';
+} | {
+    kind: 'remove-list';
+} | {
+    kind: 'adjust-list-level';
+    delta: number;
+};
+interface WordEditorRuntime {
+    readonly kind: WordEditorEngineKind;
+    readonly destroyed: boolean;
+    destroy(): void;
+    loadDocument(view: EditorDocumentView): void;
+    getSourceView(): EditorDocumentView;
+    getDocument(): NativeWordDocument;
+    getSelection(): WordEditorSelection | null;
+    setSelection(selection: WordEditorSelection | null): boolean;
+    focus(): boolean;
+    insertImage(source: string | Blob, options?: WordEditorImageInsertOptions): Promise<boolean>;
+    search(options: WordEditorSearchOptions): WordEditorSearchState;
+    getSearchState(): WordEditorSearchState | null;
+    findNext(direction?: 'forward' | 'backward'): WordEditorSearchState | null;
+    replaceCurrent(replacement: string): boolean;
+    replaceAll(replacement: string): number;
+    clearSearch(): void;
+    getCommandState(): WordEditorCommandState;
+    getChanges(): readonly NativeWordChange[];
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    canDispatch(command: WordEditorCommand): boolean;
+    dispatch(command: WordEditorCommand): boolean;
+    subscribe<Event extends WordEditorRuntimeEvent>(event: Event, listener: (payload: WordEditorRuntimeEventMap[Event]) => void): () => void;
+}
+interface WordEditorRuntimeOptions {
+    onChange?: (event: WordEditorChangeEvent) => void;
+    onSelectionChange?: (event: WordEditorSelectionChangeEvent) => void;
+    contextMenu?: boolean;
+    trackRevisions?: boolean;
+    /** Keep the editor DOM and styles inside a component boundary by default. */
+    styleIsolation?: 'shadow' | 'none';
+    /** CSS text to install inside the ShadowRoot when styleIsolation is 'shadow'. */
+    styleText?: string;
+}
+
+type NativeTableRowPaginationKind = 'repeat-header' | 'keep-together' | 'block-fragmentable' | 'text-fragmentable' | 'unsplittable';
+type NativeTableRowPaginationRisk = 'cant-split' | 'row-span' | 'vertical-merge' | 'nested-table' | 'media' | 'field' | 'page-break' | 'comment' | 'revision' | 'empty-row';
+interface NativeTableRowPaginationAnalysis {
+    kind: NativeTableRowPaginationKind;
+    risks: NativeTableRowPaginationRisk[];
+    textLength: number;
+    paragraphCount: number;
+}
+interface NativeTablePaginationSummary {
+    tables: number;
+    rows: number;
+    repeatHeaderRows: number;
+    keepTogetherRows: number;
+    blockFragmentableRows: number;
+    textFragmentableRows: number;
+    unsplittableRows: number;
+    risks: Record<NativeTableRowPaginationRisk, number>;
+}
+interface NativeTableRowBlockSplitPlan {
+    cellBlockCounts: number[];
+}
+interface NativeTableRowBlockSplitResult {
+    head: NativeWordTableRowNode;
+    tail: NativeWordTableRowNode;
+}
+interface NativeTableRowTextSplitPlan {
+    cellTextOffsets: number[];
+}
+declare function analyzeNativeTableRowPagination(row: NativeWordTableRowNode): NativeTableRowPaginationAnalysis;
+declare function summarizeNativeTablePagination(doc: NativeWordDocument): NativeTablePaginationSummary;
+declare function splitNativeTableRowAtBlockBoundary(row: NativeWordTableRowNode, plan: NativeTableRowBlockSplitPlan): NativeTableRowBlockSplitResult | null;
+declare function splitNativeTableRowAtTextOffset(row: NativeWordTableRowNode, plan: NativeTableRowTextSplitPlan): NativeTableRowBlockSplitResult | null;
+
+interface NativeAnchorLayoutMetadata {
+    classNames: string[];
+    dataset: Record<string, string>;
+    styleProperties: Record<string, string>;
+}
+interface NativeRenderOptions {
+    implicitGridForParagraphs?: boolean;
+    implicitGridLinePitch?: number;
+}
+declare function defineNativeWordElements(): void;
+declare function renderNativeDocument(doc: NativeWordDocument): HTMLElement;
+declare function paginateNativeDocument(root: HTMLElement, doc: NativeWordDocument): void;
+declare function reflowNativeDocumentFromParagraph(root: HTMLElement, doc: NativeWordDocument, paraId: string): boolean;
+interface NativeDocumentReflowMeasurement {
+    overflowPx: number;
+    canBackfillPrevious: boolean;
+    canBackfillNext: boolean;
+}
+declare function measureNativeDocumentReflowFromParagraph(root: HTMLElement, doc: NativeWordDocument, paraId: string): NativeDocumentReflowMeasurement;
+declare function rebuildNativeTableFragmentsFromParagraph(root: HTMLElement, doc: NativeWordDocument, paraId: string): boolean;
+declare function refreshNativePageCommentBubbles(root: HTMLElement): void;
+/** Keep comments and revisions in one ordered, non-overlapping page rail. */
+declare function layoutNativePageAnnotationBubbles(page: HTMLElement): void;
+declare function resolveNativeSectionPageNumberStarts(sections: Array<{
+    sectionIndex: number;
+    pageNumberStart?: number;
+}>, sectionOrder: number[], sectionPageCounts: Map<number, number>): Map<number, number>;
+declare function renderNativeBlock(block: NativeWordBlockNode, options?: NativeRenderOptions): HTMLElement;
+declare function renderNativeParagraph(paragraph: NativeWordParagraphNode, options?: NativeRenderOptions): HTMLElement;
+declare function renderNativeImage(child: NativeWordImageNode): HTMLImageElement;
+declare function nativeDrawingWidthCss(child: Pick<NativeWordDrawingNode, 'width' | 'anchoringMode' | 'wrap' | 'isLineOrConnector'>): string | undefined;
+declare function nativeAnchorLayoutMetadata(child: Pick<NativeWordImageNode | NativeWordDrawingNode, 'position' | 'wrap'>): NativeAnchorLayoutMetadata;
+declare function renderNativeTable(table: NativeWordTableNode): HTMLElement;
+interface NativeTableCellPosition {
+    rowIndex: number;
+    rowCount: number;
+    columnIndex: number;
+    columnSpan: number;
+    columnCount: number;
+}
+declare function resolveNativeTableCellBorders(table: NativeWordTableNode, cell: NativeWordTableCellNode, position: NativeTableCellPosition): EditorTableBorders | undefined;
+
+interface NativeCursorPoint {
+    paraId: string;
+    offset: number;
+}
+interface NativeSelectedImage {
+    paraId: string;
+    drawingId: string;
+}
+declare function nativeSelection(host: HTMLElement): Selection | null;
+declare function currentNativeCursor(host: HTMLElement): NativeCursorPoint | null;
+declare function nativeSelectionFromCursor(host: HTMLElement): WordEditorSelection | null;
+declare function currentNativeSelection(host: HTMLElement): WordEditorSelection | null;
+declare function nativeCursorFromPoint(host: HTMLElement, x: number, y: number): NativeCursorPoint | null;
+declare function restoreNativeCursor(host: HTMLElement, cursor: NativeCursorPoint): void;
+declare function restoreNativeTextSelection(host: HTMLElement, anchor: NativeCursorPoint, focus: NativeCursorPoint): void;
+declare function restoreNativeElementSelection(host: HTMLElement, element: HTMLElement): boolean;
+declare function createNativeTextRange(host: HTMLElement, paraId: string, from: number, to: number): Range | null;
+declare function createNativeSelectionRange(host: HTMLElement, start: NativeCursorPoint, end: NativeCursorPoint): Range | null;
+declare function selectNativeImage(host: HTMLElement, selectedImage: NativeSelectedImage): void;
+declare function clearNativeImageSelection(host: HTMLElement): void;
+declare function imageOffset(paragraph: HTMLElement, image: HTMLImageElement): number;
+declare function parentNativeParagraph(node: Node): HTMLElement | null;
+
+declare function searchNativeWordDocument(doc: NativeWordDocument, options: WordEditorSearchOptions): WordEditorSearchMatch[];
+declare function bodyParagraphs(blocks: readonly NativeWordBlockNode[]): NativeWordParagraphNode[];
+
+type NativeWordListType = 'bullet' | 'numbered';
+declare function nativeListType(numbering: EditorNumberingFormat | undefined): NativeWordListType | null;
+declare function createNativeListNumbering(doc: NativeWordDocument, type: NativeWordListType, ilvl?: number): EditorNumberingFormat;
+declare function nativeNumberingAtLevel(numbering: EditorNumberingFormat, ilvl: number): EditorNumberingFormat;
+declare function refreshNativeNumberingLabels(doc: NativeWordDocument): void;
+declare function nativeListIndent(ilvl: number): {
+    left: number;
+    firstLine: number;
+};
+declare function adjacentNativeListNumbering(doc: NativeWordDocument, paraIds: string[], type: NativeWordListType): EditorNumberingFormat | null;
+
+type WordOoxmlPatchKind = 'paragraph-text' | 'paragraph-split' | 'paragraph-merge' | 'paragraph-format' | 'format-revision' | 'drawing-delete' | 'hyperlink' | 'table-structure' | 'table-insert' | 'table-cell-format' | 'table-cell-clear' | 'table-cell-replace' | 'table-cell-replace-rich' | 'revision' | 'drawing-revision' | 'table-delete';
+type WordOoxmlPatch = {
+    kind: 'paragraph-text';
+    op: 'insert' | 'delete' | 'replace';
+    paraId: string;
+    offset: number;
+    text: string;
+    deletedText?: string;
+} | {
+    kind: 'paragraph-split';
+    paraId: string;
+    newParaId: string;
+    offset: number;
+} | {
+    kind: 'paragraph-merge';
+    paraId: string;
+} | {
+    kind: 'paragraph-format';
+    paraId: string;
+    from: number;
+    to: number;
+    format: Partial<EditorRunFormat>;
+} | {
+    kind: 'format-revision';
+    op: 'run' | 'accept' | 'reject';
+    paraId: string;
+    from: number;
+    to: number;
+    revisionId: string;
+    beforeFormat?: Partial<EditorRunFormat> | null;
+} | {
+    kind: 'drawing-delete';
+    paraId: string;
+    drawingId: string;
+    offset: number;
+} | {
+    kind: 'drawing-resize';
+    paraId: string;
+    drawingId: string;
+    offset: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'drawing-insert';
+    paraId: string;
+    drawingId: string;
+    offset: number;
+    src: string;
+    width: number;
+    height: number;
+} | {
+    kind: 'drawing-revision';
+    op: 'accept' | 'reject';
+    paraId: string;
+    drawingId: string;
+    offset: number;
+    revisionId: string;
+    revisionKind: 'insert' | 'delete';
+} | {
+    kind: 'comment';
+    op: 'insert' | 'delete' | 'update';
+    paraId: string;
+    from: number;
+    to: number;
+    commentId: number;
+    body?: string;
+    parentCommentId?: number;
+} | {
+    kind: 'revision';
+    op: 'insert' | 'delete' | 'accept' | 'reject';
+    paraId: string;
+    from: number;
+    to: number;
+    revisionId: string;
+    revisionKind: 'insert' | 'delete';
+} | {
+    kind: 'hyperlink';
+    op: 'set' | 'remove';
+    paraId: string;
+    from: number;
+    to: number;
+    hyperlink?: {
+        target?: string;
+        anchor?: string;
+        tooltip?: string;
+    };
+} | {
+    kind: 'table-structure';
+    op: 'insert-row' | 'delete-row' | 'insert-column' | 'delete-column' | 'merge-cells' | 'split-cell';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+    endColumnIndex?: number;
+    endRowIndex?: number;
+} | {
+    kind: 'table-cell-replace-rich';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+    cell: NativeWordTableCellNode;
+} | {
+    kind: 'table-cell-replace';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+    text: string;
+} | {
+    kind: 'table-cell-clear';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+} | {
+    kind: 'table-cell-format';
+    tableId: string;
+    rowIndex: number;
+    columnIndex: number;
+    format: {
+        backgroundColor?: string | null;
+        verticalAlignment?: 'top' | 'center' | 'bottom' | 'both' | null;
+        borderColor?: string | null;
+    };
+} | {
+    kind: 'table-insert';
+    anchorParaId: string;
+    anchorOffset: number;
+    table: NativeWordTableNode;
+} | {
+    kind: 'table-delete';
+    tableId: string;
+};
+interface WordOoxmlPatchPlan {
+    target: 'word/document.xml';
+    patches: WordOoxmlPatch[];
+    unsupported: UnsupportedNativeWordChange[];
+}
+type ResolvedWordOoxmlPatchTarget = {
+    kind: 'paragraph';
+    patch: Extract<WordOoxmlPatch, {
+        kind: 'paragraph-text' | 'paragraph-split' | 'paragraph-merge' | 'paragraph-format' | 'format-revision' | 'hyperlink' | 'revision';
+    }>;
+    partPath: string;
+    paragraph: Element;
+} | {
+    kind: 'table';
+    patch: Extract<WordOoxmlPatch, {
+        kind: 'table-structure' | 'table-insert' | 'table-cell-format' | 'table-cell-clear' | 'table-cell-replace' | 'table-cell-replace-rich' | 'table-delete';
+    }>;
+    partPath: string;
+    table: Element;
+    paragraph?: Element;
+} | {
+    kind: 'drawing';
+    patch: Extract<WordOoxmlPatch, {
+        kind: 'drawing-delete' | 'drawing-resize' | 'drawing-insert' | 'drawing-revision';
+    }>;
+    partPath: string;
+    drawing: Element;
+    paragraph: Element | null;
+} | {
+    kind: 'comment';
+    patch: Extract<WordOoxmlPatch, {
+        kind: 'comment';
+    }>;
+    partPath: string;
+    paragraph: Element;
+};
+interface UnresolvedWordOoxmlPatchTarget {
+    patch: WordOoxmlPatch;
+    reason: string;
+}
+interface WordOoxmlPatchTargetResolution {
+    resolved: ResolvedWordOoxmlPatchTarget[];
+    unresolved: UnresolvedWordOoxmlPatchTarget[];
+}
+interface SkippedWordOoxmlPatch {
+    patch: WordOoxmlPatch;
+    reason: string;
+}
+interface WordOoxmlPatchApplyResult {
+    applied: WordOoxmlPatch[];
+    skipped: SkippedWordOoxmlPatch[];
+    unresolved: UnresolvedWordOoxmlPatchTarget[];
+}
+interface NativeWordChangeApplyResult extends WordOoxmlPatchApplyResult {
+    plan: WordOoxmlPatchPlan;
+}
+interface UnsupportedNativeWordChange {
+    change: NativeWordChange;
+    reason: string;
+}
+declare function planWordOoxmlPatches(changes: readonly NativeWordChange[]): WordOoxmlPatchPlan;
+declare function applyNativeWordChangesToPackage(pkg: Package, changes: readonly NativeWordChange[], indices?: PackageIndices): NativeWordChangeApplyResult;
+declare function planWordOoxmlPatch(change: NativeWordChange, options?: {
+    allowTrackedTable?: boolean;
+}): WordOoxmlPatch | null;
+declare function resolveWordOoxmlPatchTargets(pkg: Package, indices: PackageIndices, patches: readonly WordOoxmlPatch[]): WordOoxmlPatchTargetResolution;
+declare function applyWordOoxmlPatches(pkg: Package, indices: PackageIndices, patches: readonly WordOoxmlPatch[]): WordOoxmlPatchApplyResult;
+
+declare function getNativeWordCommandState(doc: NativeWordDocument, selection: WordEditorSelection | null): WordEditorCommandState;
+declare function canDispatchNativeWordCommand(doc: NativeWordDocument, selection: WordEditorSelection | null, command: WordEditorCommand): boolean;
+
+interface NativeWordEditor extends WordEditorRuntime {
+}
+declare function renderNativeWordEditor(host: HTMLElement, initialView: EditorDocumentView, options?: WordEditorRuntimeOptions): NativeWordEditor;
+
+export { type WordEditorFormatValue as $, type NativeWordCommentMark as A, type NativeWordDocument as B, type NativeWordDrawingNode as C, type NativeWordEditor as D, type NativeWordFieldNode as E, type NativeWordFormatRevisionMark as F, type NativeWordHeaderFooterStory as G, type NativeWordImageNode as H, type NativeWordInlineNode as I, type NativeWordListType as J, type NativeWordPageBreakNode as K, type NativeWordParagraphNode as L, type NativeWordRevisionMark as M, type NativeAnchorLayoutMetadata as N, type NativeWordTableCellNode as O, type NativeWordTableNode as P, type NativeWordTableRowNode as Q, type NativeWordTextMark as R, type NativeWordTextNode as S, type ResolvedWordOoxmlPatchTarget as T, type SkippedWordOoxmlPatch as U, type UnresolvedWordOoxmlPatchTarget as V, type UnsupportedNativeWordChange as W, type WordEditorChangeEvent as X, type WordEditorCommand as Y, type WordEditorCommandState as Z, type WordEditorEngineKind as _, type NativeBlockRangeReplacement as a, nativeInsertImage as a$, type WordEditorHyperlink as a0, type WordEditorImageInsertOptions as a1, type WordEditorImageState as a2, type WordEditorLineSpacingState as a3, type WordEditorRuntime as a4, type WordEditorRuntimeEvent as a5, type WordEditorRuntimeEventMap as a6, type WordEditorRuntimeOptions as a7, type WordEditorSearchMatch as a8, type WordEditorSearchOptions as a9, currentNativeSelection as aA, defineNativeWordElements as aB, findNativeParagraph as aC, findNativeParagraphLocation as aD, findNativeTableCellLocation as aE, findNativeTableLocation as aF, getNativeWordCommandState as aG, imageOffset as aH, layoutNativePageAnnotationBubbles as aI, measureNativeDocumentReflowFromParagraph as aJ, nativeAddComment as aK, nativeAddFormatRevision as aL, nativeAddRevision as aM, nativeAnchorLayoutMetadata as aN, nativeClearRunFormat as aO, nativeClearTableCellRange as aP, nativeCopyBlockRange as aQ, nativeCursorFromPoint as aR, nativeDeleteBackward as aS, nativeDeleteComment as aT, nativeDeleteForward as aU, nativeDeleteImage as aV, nativeDeleteRange as aW, nativeDeleteTable as aX, nativeDeleteTextRangeAcrossParagraphs as aY, nativeDrawingWidthCss as aZ, nativeEditTableStructure as a_, type WordEditorSearchState as aa, type WordEditorSelection as ab, type WordEditorSelectionChangeEvent as ac, type WordEditorSelectionPoint as ad, type WordEditorTableCellPoint as ae, type WordEditorTableState as af, type WordOoxmlPatch as ag, type WordOoxmlPatchApplyResult as ah, type WordOoxmlPatchKind as ai, type WordOoxmlPatchPlan as aj, type WordOoxmlPatchTargetResolution as ak, adjacentNativeListNumbering as al, allNativeParagraphs as am, analyzeNativeTableRowPagination as an, applyNativeWordChangesToPackage as ao, applyWordOoxmlPatches as ap, bodyParagraphs as aq, canDispatchNativeWordCommand as ar, clearNativeImageSelection as as, cloneNativeWordBlocks as at, createNativeListNumbering as au, createNativeParaId as av, createNativeSelectionRange as aw, createNativeTextRange as ax, createNativeWordDocument as ay, currentNativeCursor as az, type NativeCursorPoint as b, nativeInsertPageBreak as b0, nativeInsertTable as b1, nativeInsertText as b2, nativeListIndent as b3, nativeListType as b4, nativeMergeTableCells as b5, nativeNumberingAtLevel as b6, nativePageBreakAt as b7, nativeParagraphText as b8, nativeRangeContainsPageBreak as b9, nativeUpdateComment as bA, paginateNativeDocument as bB, parentNativeParagraph as bC, planWordOoxmlPatch as bD, planWordOoxmlPatches as bE, previousNativeParagraphId as bF, rebuildNativeTableFragmentsFromParagraph as bG, reflowNativeDocumentFromParagraph as bH, refreshNativeNumberingLabels as bI, refreshNativePageCommentBubbles as bJ, renderNativeBlock as bK, renderNativeDocument as bL, renderNativeImage as bM, renderNativeParagraph as bN, renderNativeTable as bO, renderNativeWordEditor as bP, resolveNativeSectionPageNumberStarts as bQ, resolveNativeTableCellBorders as bR, resolveWordOoxmlPatchTargets as bS, restoreNativeCursor as bT, restoreNativeElementSelection as bU, restoreNativeTextSelection as bV, searchNativeWordDocument as bW, selectNativeImage as bX, splitNativeTableRowAtBlockBoundary as bY, splitNativeTableRowAtTextOffset as bZ, summarizeNativeTablePagination as b_, nativeReplaceBlockRangeAcrossParagraphs as ba, nativeReplaceRange as bb, nativeReplaceRangeWithBlocks as bc, nativeReplaceTableCellRangeContent as bd, nativeReplaceTableCellRangeText as be, nativeReplaceTextRangeAcrossParagraphs as bf, nativeReplaceTextRangeWithParagraphs as bg, nativeResolveFormatRevision as bh, nativeResolveImageFormatRevision as bi, nativeResolveImageRevision as bj, nativeResolveRevision as bk, nativeSelection as bl, nativeSelectionFromCursor as bm, nativeSetHyperlink as bn, nativeSetImageSize as bo, nativeSetParagraphFormat as bp, nativeSetParagraphList as bq, nativeSetRunFormat as br, nativeSetTableCellFormat as bs, nativeSetTableCellRangeFormat as bt, nativeSplitParagraph as bu, nativeSplitTableCell as bv, nativeSyncParagraphText as bw, nativeTableCellsInRange as bx, nativeTableSupportsStructuralEditing as by, nativeTextRangeIsBold as bz, type NativeDocumentReflowMeasurement as c, type NativeParagraphLocation as d, type NativePlainTextReplacement as e, type NativeSelectedImage as f, type NativeTableCellFormatPatch as g, type NativeTableCellLocation as h, type NativeTableCellPoint as i, type NativeTableCellPosition as j, type NativeTableCellRange as k, type NativeTableClipboardCell as l, type NativeTableEditResult as m, type NativeTableLocation as n, type NativeTablePaginationSummary as o, type NativeTableRangeEditResult as p, type NativeTableRowBlockSplitPlan as q, type NativeTableRowBlockSplitResult as r, type NativeTableRowPaginationAnalysis as s, type NativeTableRowPaginationKind as t, type NativeTableRowPaginationRisk as u, type NativeTableRowTextSplitPlan as v, type NativeTableStructureOperation as w, type NativeWordBlockNode as x, type NativeWordChange as y, type NativeWordChangeApplyResult as z };