@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/public-types-7ZL_94cz.d.ts

@@ -0,0 +1,1573 @@
+import { d as PersistedEditorSnapshotVersion, e as CDS_SCHEMA_VERSION, I as ISO8601DateTime, C as CanonicalDocument, f as CompatibilityReportVersion, g as Base64, h as CommentThread, i as CommentEntry, j as CommentResolution, R as RevisionMetadataRecord$1, k as RevisionRecord$1, S as SupportedFieldFamily$1, F as FieldRefreshStatus$1, l as FieldFamily$1 } from './canonical-document-BLEbzL2J.js';
+
+type Position = number;
+type Assoc = -1 | 1;
+interface DocRange {
+    from: Position;
+    to: Position;
+}
+interface BoundaryAssoc {
+    start: Assoc;
+    end: Assoc;
+}
+interface RangeAnchor {
+    kind: "range";
+    range: DocRange;
+    assoc: BoundaryAssoc;
+}
+interface NodeAnchor {
+    kind: "node";
+    at: Position;
+    assoc: Assoc;
+}
+interface DetachedAnchor {
+    kind: "detached";
+    lastKnownRange: DocRange;
+    reason: "deleted" | "invalidatedByStructureChange" | "importAmbiguity";
+}
+type EditorAnchorProjection$1 = RangeAnchor | NodeAnchor | DetachedAnchor;
+interface MappingStep {
+    from: Position;
+    to: Position;
+    insertSize: number;
+}
+interface MappingResult {
+    position: Position;
+    deleted: boolean;
+}
+interface TransactionMapping {
+    steps: MappingStep[];
+    metadata?: {
+        invalidatesStructures?: boolean;
+        affectsComments?: boolean;
+        affectsRevisions?: boolean;
+        affectsOpaqueFragments?: boolean;
+        [key: string]: unknown;
+    };
+}
+declare const DEFAULT_BOUNDARY_ASSOC: BoundaryAssoc;
+declare function createRangeAnchor(from: Position, to?: number, assoc?: BoundaryAssoc): RangeAnchor;
+declare function createNodeAnchor(at: Position, assoc?: Assoc): NodeAnchor;
+declare function createDetachedAnchor(lastKnownRange: DocRange, reason: DetachedAnchor["reason"]): DetachedAnchor;
+declare function createEmptyMapping(): TransactionMapping;
+declare function normalizeRange(range: DocRange): DocRange;
+declare function getEffectiveRange(anchor: EditorAnchorProjection$1): DocRange;
+declare function mapPosition(position: Position, assoc: Assoc, mapping: TransactionMapping): MappingResult;
+declare function mapAnchor(anchor: EditorAnchorProjection$1, mapping: TransactionMapping): EditorAnchorProjection$1;
+declare function mapRange(range: DocRange, assoc: BoundaryAssoc, mapping: TransactionMapping): RangeAnchor | DetachedAnchor;
+declare function areAnchorsEqual(left: EditorAnchorProjection$1, right: EditorAnchorProjection$1): boolean;
+declare function storyTargetsEqual(left: EditorStoryTarget | undefined, right: EditorStoryTarget | undefined): boolean;
+declare const MAIN_STORY_TARGET: EditorStoryTarget;
+
+type EditorWarningCode$2 = "unsupported_ooxml_preserved" | "unsupported_ooxml_locked" | "import_normalized" | "export_roundtrip_risk" | "comment_anchor_detached" | "revision_anchor_detached" | "large_document_degraded" | "font_substitution" | "image_missing";
+interface EditorWarning$2 {
+    warningId: string;
+    code: EditorWarningCode$2;
+    severity: "info" | "warning";
+    message: string;
+    source: "import" | "runtime" | "review" | "preservation" | "validation" | "export";
+    affectedAnchor?: Record<string, unknown>;
+    featureEntryId?: string;
+    details?: Record<string, unknown>;
+}
+type EditorErrorCode$1 = "import_failed" | "export_failed" | "package_corrupt" | "validation_failed" | "datastore_failed" | "internal_invariant";
+interface EditorError$2 {
+    errorId: string;
+    code: EditorErrorCode$1;
+    message: string;
+    isFatal: boolean;
+    source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
+    details?: Record<string, unknown>;
+}
+type CompatibilityFeatureClass$2 = "supported-roundtrip" | "preserve-only" | "unsupported-fatal";
+interface CompatibilityFeatureEntry$2 {
+    featureEntryId: string;
+    featureKey: string;
+    featureClass: CompatibilityFeatureClass$2;
+    message: string;
+    affectedAnchor?: Record<string, unknown>;
+    details?: Record<string, unknown>;
+}
+interface CompatibilityReport$2 {
+    reportVersion: CompatibilityReportVersion;
+    generatedAt: ISO8601DateTime;
+    blockExport: boolean;
+    featureEntries: CompatibilityFeatureEntry$2[];
+    warnings: EditorWarning$2[];
+    errors: EditorError$2[];
+}
+interface PersistedSourcePackage {
+    format: "docx";
+    storage: "embedded-base64";
+    mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    sourceLabel?: string;
+    sha256Hex: string;
+    bytesBase64: Base64;
+}
+interface PersistedEditorSnapshot$2 {
+    snapshotVersion: PersistedEditorSnapshotVersion;
+    schemaVersion: typeof CDS_SCHEMA_VERSION;
+    documentId: string;
+    docId: string;
+    createdAt: ISO8601DateTime;
+    updatedAt: ISO8601DateTime;
+    savedAt: ISO8601DateTime;
+    editorBuild: string;
+    canonicalDocument: CanonicalDocument;
+    compatibility: CompatibilityReport$2;
+    warningLog: EditorWarning$2[];
+    protectionSnapshot?: ProtectionSnapshotRecord;
+    sourcePackage?: PersistedSourcePackage;
+}
+interface ProtectionRangeRecord {
+    rangeId: string;
+    start?: number;
+    end?: number;
+    editorGroup?: string;
+    editor?: string;
+    enforced: boolean;
+    enforcementReason: string;
+}
+interface ProtectionSnapshotRecord {
+    hasDocumentProtection: boolean;
+    editType?: string;
+    enforcementActive: boolean;
+    ranges: ProtectionRangeRecord[];
+    enforcedRangeCount: number;
+    preservedRangeCount: number;
+}
+
+type RuntimePhase = "loading" | "ready" | "error";
+type EditorWarningCode$1 = "unsupported_ooxml_preserved" | "unsupported_ooxml_locked" | "import_normalized" | "export_roundtrip_risk" | "comment_anchor_detached" | "revision_anchor_detached" | "large_document_degraded" | "font_substitution" | "image_missing";
+interface EditorWarning$1 {
+    warningId: string;
+    code: EditorWarningCode$1;
+    severity: "info" | "warning";
+    message: string;
+    source: "import" | "runtime" | "review" | "preservation" | "validation" | "export";
+    affectedAnchor?: EditorAnchorProjection$1;
+    featureEntryId?: string;
+    details?: Record<string, unknown>;
+}
+interface EditorError$1 {
+    errorId: string;
+    code: "import_failed" | "export_failed" | "package_corrupt" | "validation_failed" | "datastore_failed" | "internal_invariant";
+    message: string;
+    isFatal: boolean;
+    source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
+    details?: Record<string, unknown>;
+}
+type CompatibilityFeatureClass$1 = "supported-roundtrip" | "preserve-only" | "unsupported-fatal";
+interface CompatibilityFeatureEntry$1 {
+    featureEntryId: string;
+    featureKey: string;
+    featureClass: CompatibilityFeatureClass$1;
+    message: string;
+    affectedAnchor?: EditorAnchorProjection$1;
+    details?: Record<string, unknown>;
+}
+interface CompatibilityReport$1 {
+    reportVersion: "compatibility-report/1";
+    generatedAt: string;
+    blockExport: boolean;
+    featureEntries: CompatibilityFeatureEntry$1[];
+    warnings: EditorWarning$1[];
+    errors: EditorError$1[];
+}
+type CommentEntryRecord = CommentEntry;
+type CommentResolutionRecord = CommentResolution;
+type CommentThreadRecord = CommentThread;
+type RevisionMetadataRecord = RevisionMetadataRecord$1;
+type RevisionRecord = RevisionRecord$1;
+type ReviewStore = CanonicalDocument["review"];
+type CanonicalDocumentEnvelope = CanonicalDocument;
+interface SelectionSnapshot$1 {
+    anchor: number;
+    head: number;
+    isCollapsed: boolean;
+    activeRange: EditorAnchorProjection$1;
+}
+interface DocumentStats$1 {
+    paragraphCount: number;
+    wordCount: number;
+    characterCount: number;
+    commentCount: number;
+    revisionCount: number;
+}
+interface CommentSidebarSnapshot$1 {
+    activeCommentId?: string;
+    openThreadCount: number;
+    resolvedThreadCount: number;
+    threads: CommentThreadRecord[];
+}
+interface TrackedChangesSnapshot$1 {
+    totalCount: number;
+    pendingCount: number;
+    acceptedCount: number;
+    rejectedCount: number;
+}
+interface CompatibilityPanelSnapshot$1 {
+    report: CompatibilityReport$1;
+    blockExport: boolean;
+    totalEntries: number;
+}
+interface CommandStateSnapshot$1 {
+    canUndo: boolean;
+    canRedo: boolean;
+    canAddComment: boolean;
+    canAcceptAllChanges: boolean;
+    canRejectAllChanges: boolean;
+}
+interface RuntimeRenderSnapshot$1 {
+    documentId: string;
+    sessionId: string;
+    sourceLabel?: string;
+    revisionToken: string;
+    isReady: boolean;
+    isDirty: boolean;
+    readOnly: boolean;
+    selection: SelectionSnapshot$1;
+    documentStats: DocumentStats$1;
+    comments: CommentSidebarSnapshot$1;
+    trackedChanges: TrackedChangesSnapshot$1;
+    compatibility: CompatibilityPanelSnapshot$1;
+    warnings: EditorWarning$1[];
+    fatalError?: EditorError$1;
+    commandState: CommandStateSnapshot$1;
+}
+interface PersistedEditorSnapshot$1 extends Omit<PersistedEditorSnapshot$2, "canonicalDocument" | "compatibility" | "warningLog"> {
+    canonicalDocument: CanonicalDocumentEnvelope;
+    compatibility: CompatibilityReport$1;
+    warningLog: EditorWarning$1[];
+}
+interface EditorRuntimeState {
+    hasFocus: boolean;
+    activeCommentId?: string;
+}
+interface EditorState {
+    phase: RuntimePhase;
+    documentId: string;
+    sessionId: string;
+    sourceLabel?: string;
+    sourcePackage?: PersistedEditorSnapshot$2["sourcePackage"];
+    revision: number;
+    revisionToken: string;
+    isDirty: boolean;
+    readOnly: boolean;
+    document: CanonicalDocumentEnvelope;
+    selection: SelectionSnapshot$1;
+    warnings: EditorWarning$1[];
+    compatibility: CompatibilityReport$1;
+    fatalError?: EditorError$1;
+    runtime: EditorRuntimeState;
+}
+interface CreateEditorStateOptions {
+    documentId: string;
+    sessionId: string;
+    sourceLabel?: string;
+    readOnly?: boolean;
+    canonicalDocument?: CanonicalDocumentEnvelope;
+    persistedSnapshot?: PersistedEditorSnapshot$1;
+    compatibility?: CompatibilityReport$1;
+    warnings?: EditorWarning$1[];
+    fatalError?: EditorError$1;
+}
+declare function createEmptyReviewStore(): ReviewStore;
+declare function createDefaultCanonicalDocument(documentId: string, timestamp: string): CanonicalDocumentEnvelope;
+declare function createSelectionSnapshot(anchor?: number, head?: number): SelectionSnapshot$1;
+declare function createEmptyCompatibilityReport(generatedAt: string): CompatibilityReport$1;
+declare function createEditorState(options: CreateEditorStateOptions): EditorState;
+declare function deriveDocumentStats(state: Pick<EditorState, "document">): DocumentStats$1;
+declare function deriveRenderSnapshot(state: EditorState, history: {
+    canUndo: boolean;
+    canRedo: boolean;
+}): RuntimeRenderSnapshot$1;
+declare function createPersistedEditorSnapshot(state: EditorState, options: {
+    editorBuild: string;
+    savedAt: string;
+    compatibility?: CompatibilityReport$1;
+    protectionSnapshot?: ProtectionSnapshotRecord;
+}): PersistedEditorSnapshot$1;
+declare function createCanonicalDocumentId(documentId: string): string;
+declare function normalizeCommentThreadRecord(value: unknown): CommentThreadRecord;
+
+type FieldFamily = FieldFamily$1;
+type FieldRefreshStatus = FieldRefreshStatus$1;
+type SupportedFieldFamily = SupportedFieldFamily$1;
+type ExternalDocumentSource = {
+    kind: "docx";
+    bytes: Uint8Array | ArrayBuffer;
+    sourceLabel?: string;
+} | {
+    kind: "session";
+    sessionState: EditorSessionState;
+    sourceLabel?: string;
+} | {
+    kind: "snapshot";
+    snapshot: PersistedEditorSnapshot;
+    sourceLabel?: string;
+};
+type LoadSourcePolicy = "prefer-saved-state" | "prefer-source-package";
+interface LoadRequest {
+    documentId: string;
+    loadRevision?: string;
+    loadSourcePolicy?: LoadSourcePolicy;
+}
+interface EditorUser {
+    userId: string;
+    displayName: string;
+    email?: string;
+    avatarUrl?: string;
+}
+type EditorAnchorProjection = {
+    kind: "range";
+    from: number;
+    to: number;
+    assoc: {
+        start: -1 | 1;
+        end: -1 | 1;
+    };
+} | {
+    kind: "node";
+    at: number;
+    assoc: -1 | 1;
+} | {
+    kind: "detached";
+    lastKnownRange: {
+        from: number;
+        to: number;
+    };
+    reason: "deleted" | "invalidatedByStructureChange" | "importAmbiguity";
+};
+type EditorStoryTarget = {
+    kind: "main";
+} | {
+    kind: "header";
+    relationshipId: string;
+    variant: "default" | "first" | "even";
+    sectionIndex?: number;
+} | {
+    kind: "footer";
+    relationshipId: string;
+    variant: "default" | "first" | "even";
+    sectionIndex?: number;
+} | {
+    kind: "footnote";
+    noteId: string;
+} | {
+    kind: "endnote";
+    noteId: string;
+};
+interface SelectionSnapshot {
+    anchor: number;
+    head: number;
+    isCollapsed: boolean;
+    activeRange: EditorAnchorProjection;
+    storyTarget?: EditorStoryTarget;
+}
+interface PageLayoutSnapshot {
+    sectionIndex: number;
+    sectionType?: "continuous" | "nextPage" | "evenPage" | "oddPage" | "nextColumn";
+    pageWidth: number;
+    pageHeight: number;
+    marginTop: number;
+    marginBottom: number;
+    marginLeft: number;
+    marginRight: number;
+    headerMargin: number;
+    footerMargin: number;
+    gutter: number;
+    orientation: "portrait" | "landscape";
+    columns: number;
+    differentFirstPage: boolean;
+    differentOddEvenPages: boolean;
+    pageNumbering?: {
+        format?: string;
+        start?: number;
+        chapterStyle?: string;
+        chapterSeparator?: string;
+    };
+    lineNumbering?: {
+        countBy?: number;
+        start?: number;
+        distance?: number;
+        restart?: "newPage" | "newSection" | "continuous";
+    };
+    pageBorders?: {
+        top?: {
+            value?: string;
+            size?: number;
+            space?: number;
+            color?: string;
+        };
+        left?: {
+            value?: string;
+            size?: number;
+            space?: number;
+            color?: string;
+        };
+        bottom?: {
+            value?: string;
+            size?: number;
+            space?: number;
+            color?: string;
+        };
+        right?: {
+            value?: string;
+            size?: number;
+            space?: number;
+            color?: string;
+        };
+        offsetFrom?: "page" | "text";
+        display?: "allPages" | "firstPage" | "notFirstPage";
+        zOrder?: "front" | "back";
+    };
+    documentGrid?: {
+        type?: "default" | "lines" | "linesAndChars" | "snapToChars";
+        linePitch?: number;
+        charSpace?: number;
+    };
+    columnDefinitions: Array<{
+        width: number;
+        space?: number;
+    }>;
+    equalWidthColumns: boolean;
+    columnSeparator: boolean;
+    headerVariants: Array<{
+        variant: "default" | "first" | "even";
+        relationshipId: string;
+    }>;
+    footerVariants: Array<{
+        variant: "default" | "first" | "even";
+        relationshipId: string;
+    }>;
+}
+type WorkspaceMode = "canvas" | "page";
+type ZoomLevel = "pageWidth" | "onePage" | number;
+type SectionBreakType = "nextPage" | "continuous" | "evenPage" | "oddPage" | "nextColumn";
+interface SectionLayoutPatch {
+    pageSize?: Partial<{
+        width: number;
+        height: number;
+        orientation: "portrait" | "landscape";
+    }>;
+    pageMargins?: Partial<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+        header: number;
+        footer: number;
+        gutter: number;
+    }>;
+    columns?: Partial<{
+        count: number;
+        space: number;
+        equalWidth: boolean;
+        columns: Array<{
+            width: number;
+            space?: number;
+        }>;
+        separator: boolean;
+    }>;
+    titlePage?: boolean;
+    sectionType?: SectionBreakType;
+}
+interface SectionPageNumberingPatch {
+    format?: string | null;
+    start?: number | null;
+    chapterStyle?: string | null;
+    chapterSeparator?: string | null;
+}
+interface HeaderFooterLinkPatch {
+    kind: "header" | "footer";
+    variant: "default" | "first" | "even";
+    linkToPrevious: boolean;
+    relationshipId?: string | null;
+}
+interface DocumentStats {
+    storyLength: number;
+    commentCount: number;
+    revisionCount: number;
+    opaqueFragmentCount: number;
+}
+interface CommentSidebarSnapshot {
+    activeCommentId?: string;
+    openCommentIds: string[];
+    resolvedCommentIds: string[];
+    detachedCommentIds: string[];
+    totalCount: number;
+    threads: CommentSidebarThreadSnapshot[];
+}
+interface CommentSidebarThreadEntrySnapshot {
+    entryId: string;
+    authorId: string;
+    body: string;
+    createdAt: string;
+}
+interface CommentSidebarThreadSnapshot {
+    commentId: string;
+    status: "open" | "resolved" | "detached";
+    anchor: EditorAnchorProjection;
+    excerpt: string;
+    entryCount: number;
+    entries: CommentSidebarThreadEntrySnapshot[];
+    createdAt: string;
+    createdBy: string;
+    warningCount: number;
+    anchorLabel: string;
+    isActive: boolean;
+    resolvedAt?: string;
+    resolvedBy?: string;
+}
+interface TrackedChangeEntrySnapshot {
+    revisionId: string;
+    kind: "insertion" | "deletion" | "formatting" | "move" | "property-change";
+    label: string;
+    status: "active" | "accepted" | "rejected" | "detached";
+    actionability: "actionable" | "preserve-only";
+    storyTarget?: EditorStoryTarget;
+    importedRevisionForm?: "run-insertion" | "run-deletion" | "paragraph-insertion" | "paragraph-deletion";
+    anchor: EditorAnchorProjection;
+    anchorLabel: string;
+    createdAt: string;
+    authorId: string;
+    warningCount: number;
+    canAccept: boolean;
+    canReject: boolean;
+    preserveOnlyReason?: string;
+    excerpt?: string;
+    detail?: string;
+}
+interface TrackedChangesSnapshot {
+    pendingChangeIds: string[];
+    acceptedChangeIds: string[];
+    rejectedChangeIds: string[];
+    detachedChangeIds: string[];
+    actionableChangeIds: string[];
+    preserveOnlyChangeIds: string[];
+    totalCount: number;
+    revisions: TrackedChangeEntrySnapshot[];
+}
+type FormattingAlignment = "left" | "center" | "right" | "justify";
+interface FormattingBreadcrumbItem {
+    kind: "table" | "table_row" | "table_cell" | "paragraph" | "sdt_block" | "opaque_block";
+    label: string;
+    from: number;
+    to: number;
+}
+interface FormattingStateSnapshot {
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strikethrough: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    fontFamily?: string;
+    fontSize?: number;
+    textColor?: string;
+    highlightColor?: string | null;
+    alignment?: FormattingAlignment;
+    paragraphStyleId?: string;
+    breadcrumb: FormattingBreadcrumbItem[];
+}
+interface SearchOptions {
+    matchCase?: boolean;
+    wholeWord?: boolean;
+    limit?: number;
+}
+interface SearchResultSnapshot {
+    resultId: string;
+    anchor: EditorAnchorProjection;
+    excerpt: string;
+    isActive: boolean;
+    storyTarget?: EditorStoryTarget;
+    sectionIndex?: number;
+    pageIndex?: number;
+}
+/**
+ * Runtime-owned snapshot of the document's page stack, heading outline, and
+ * navigation context.  Derived from canonical document state and section
+ * properties — never from DOM scroll position or CSS layout.
+ */
+interface DocumentNavigationSnapshot {
+    /** Total estimated page count across all sections. */
+    pageCount: number;
+    /** Ordered page descriptors, one per logical page. */
+    pages: DocumentPageSnapshot[];
+    /** Ordered heading outline extracted from paragraph styles. */
+    headings: DocumentHeadingSnapshot[];
+    /** Index of the page containing the current selection head. */
+    activePageIndex: number;
+    /** Section index containing the current selection head. */
+    activeSectionIndex: number;
+}
+/** Runtime-derived descriptor for a single logical page. */
+interface DocumentPageSnapshot {
+    /** Zero-based page index within the whole document. */
+    pageIndex: number;
+    /** Section that owns this page (zero-based). */
+    sectionIndex: number;
+    /** Zero-based page index within its owning section. */
+    pageInSection: number;
+    /** Estimated character offset where the page begins in the main story. */
+    startOffset: number;
+    /** Estimated character offset where the page ends in the main story. */
+    endOffset: number;
+    /** Page layout properties inherited from the section. */
+    layout: PageLayoutSnapshot;
+}
+/** A heading entry in the document outline. */
+interface DocumentHeadingSnapshot {
+    /** Stable identifier for the heading (derived from block position). */
+    headingId: string;
+    /** Outline level (1 = Heading 1, 2 = Heading 2, etc.). */
+    level: number;
+    /** Plain-text content of the heading paragraph. */
+    text: string;
+    /** Character offset of the heading in the main story. */
+    offset: number;
+    /** Zero-based page index where the heading lives. */
+    pageIndex: number;
+    /** Section index where the heading lives. */
+    sectionIndex: number;
+}
+/** A single field entry in the runtime field snapshot. */
+interface FieldEntrySnapshot {
+    /** Stable index of the field in document order. */
+    index: number;
+    /** Classified field family. */
+    fieldFamily: FieldFamily;
+    /** Whether this family is in the supported refresh slice. */
+    supported: boolean;
+    /** Raw field instruction string. */
+    instruction: string;
+    /** Target bookmark for REF/PAGEREF/NOTEREF fields. */
+    fieldTarget?: string;
+    /** Current refresh status. */
+    refreshStatus: FieldRefreshStatus;
+    /** Resolved display text (from field children). */
+    displayText: string;
+}
+/** Runtime field snapshot — read-only view of all fields in the document. */
+interface FieldSnapshot {
+    /** Total number of fields in the document. */
+    totalCount: number;
+    /** Number of fields in the supported refresh slice. */
+    supportedCount: number;
+    /** Number of fields that are preserve-only. */
+    preserveOnlyCount: number;
+    /** Ordered field entries. */
+    fields: FieldEntrySnapshot[];
+}
+/** Options for runtime-backed field refresh. */
+interface UpdateFieldsOptions {
+    /** When true, only refresh fields in the supported slice. Default true. */
+    supportedOnly?: boolean;
+}
+/** Result of a runtime-backed field refresh operation. */
+interface UpdateFieldsResult {
+    /** Total number of fields in the document. */
+    totalCount: number;
+    /** Number of fields that were refreshed. */
+    updatedCount: number;
+    /** Number of preserve-only fields left unchanged. */
+    preserveOnlyCount: number;
+}
+/** Options for runtime-backed TOC refresh. */
+interface TocRefreshOptions {
+    /** Maximum heading outline level to include (1–9, default 3). */
+    maxLevel?: number;
+}
+/** Result of a TOC refresh operation. */
+interface TocRefreshResult {
+    /** Number of TOC entries generated from heading structure. */
+    entryCount: number;
+    /** Heading entries that populated the TOC. */
+    entries: Array<{
+        level: number;
+        text: string;
+        pageIndex: number;
+    }>;
+}
+interface StyleCatalogEntrySnapshot {
+    styleId: string;
+    displayName: string;
+    kind: "paragraph" | "character" | "table";
+    isDefault: boolean;
+    basedOn?: string;
+    nextStyle?: string;
+}
+interface StyleCatalogSnapshot {
+    paragraphs: StyleCatalogEntrySnapshot[];
+    characters: StyleCatalogEntrySnapshot[];
+    tables: StyleCatalogEntrySnapshot[];
+    fromPackage: boolean;
+}
+interface InsertTableOptions {
+    rows: number;
+    columns: number;
+}
+interface InsertImageOptions {
+    data: Uint8Array;
+    mimeType: string;
+    width?: number;
+    height?: number;
+    altText?: string;
+}
+type SurfaceTextMark = "bold" | "italic" | "underline" | "strikethrough" | "doubleStrikethrough" | "superscript" | "subscript" | "vanish" | "emboss" | "imprint" | "shadow" | "smallCaps" | "allCaps";
+type SurfaceInlineSegment = {
+    segmentId: string;
+    kind: "text";
+    from: number;
+    to: number;
+    text: string;
+    marks?: SurfaceTextMark[];
+    markAttrs?: {
+        backgroundColor?: string;
+        charSpacing?: number;
+        kerning?: number;
+        textFill?: string;
+        fontFamily?: string;
+        fontSize?: number;
+        textColor?: string;
+    };
+    hyperlinkHref?: string;
+} | {
+    segmentId: string;
+    kind: "tab" | "hard_break";
+    from: number;
+    to: number;
+    hyperlinkHref?: string;
+} | {
+    segmentId: string;
+    kind: "image";
+    from: number;
+    to: number;
+    mediaId: string;
+    altText?: string;
+    state: "editable" | "missing";
+    display?: "inline" | "floating";
+    detail?: string;
+} | {
+    segmentId: string;
+    kind: "opaque_inline";
+    from: number;
+    to: number;
+    fragmentId: string;
+    warningId: string;
+    label: string;
+    detail: string;
+    presentation?: "inline-chip" | "quiet-marker";
+    state: "locked-preserve-only";
+} | {
+    segmentId: string;
+    kind: "note_ref";
+    from: number;
+    to: number;
+    noteKind: "footnote" | "endnote";
+    noteId: string;
+    label: string;
+} | {
+    segmentId: string;
+    kind: "field_ref";
+    from: number;
+    to: number;
+    fieldFamily: SupportedFieldFamily;
+    fieldTarget?: string;
+    instruction: string;
+    refreshStatus: FieldRefreshStatus;
+    label: string;
+};
+interface SurfaceTableCellSnapshot {
+    gridSpan: number;
+    verticalMerge: "restart" | "continue" | null;
+    colspan: number;
+    rowspan: number;
+    backgroundColor?: string | null;
+    verticalAlign?: "top" | "center" | "bottom" | null;
+    borderTop?: string | null;
+    borderRight?: string | null;
+    borderBottom?: string | null;
+    borderLeft?: string | null;
+    content: SurfaceBlockSnapshot[];
+}
+interface SurfaceTableRowSnapshot {
+    cells: SurfaceTableCellSnapshot[];
+    gridBefore?: number;
+    gridAfter?: number;
+    height?: number;
+    heightRule?: "auto" | "atLeast" | "exact";
+    isHeader?: boolean;
+}
+type SurfaceBlockSnapshot = {
+    blockId: string;
+    kind: "paragraph";
+    from: number;
+    to: number;
+    styleId?: string;
+    numbering?: {
+        numberingInstanceId: string;
+        level: number;
+    };
+    numberingPrefix?: string;
+    numberingSuffix?: "tab" | "space" | "nothing";
+    alignment?: "left" | "center" | "right" | "both" | "distribute";
+    spacing?: {
+        before?: number;
+        after?: number;
+        line?: number;
+        lineRule?: string;
+    };
+    contextualSpacing?: boolean;
+    indentation?: {
+        left?: number;
+        right?: number;
+        firstLine?: number;
+        hanging?: number;
+    };
+    borders?: {
+        top?: unknown;
+        left?: unknown;
+        bottom?: unknown;
+        right?: unknown;
+        bar?: unknown;
+        between?: unknown;
+    };
+    shading?: {
+        fill?: string;
+        color?: string;
+        val?: string;
+    };
+    tabStops?: Array<{
+        pos: number;
+        val?: string;
+        leader?: string;
+    }>;
+    keepNext?: boolean;
+    keepLines?: boolean;
+    pageBreakBefore?: boolean;
+    outlineLevel?: number;
+    bidi?: boolean;
+    suppressLineNumbers?: boolean;
+    segments: SurfaceInlineSegment[];
+} | {
+    blockId: string;
+    kind: "table";
+    from: number;
+    to: number;
+    styleId?: string;
+    gridColumns: number[];
+    alignment?: "left" | "center" | "right";
+    tblLook?: {
+        firstRow?: boolean;
+        lastRow?: boolean;
+        firstColumn?: boolean;
+        lastColumn?: boolean;
+        noHBand?: boolean;
+        noVBand?: boolean;
+    };
+    rows: SurfaceTableRowSnapshot[];
+} | {
+    blockId: string;
+    kind: "sdt_block";
+    from: number;
+    to: number;
+    sdtType?: string;
+    alias?: string;
+    tag?: string;
+    lock?: string;
+    checkboxChecked?: boolean;
+    dateValue?: string;
+    dropdownItems?: Array<{
+        displayText?: string;
+        value: string;
+    }>;
+    comboBoxItems?: Array<{
+        displayText?: string;
+        value: string;
+    }>;
+    showingPlcHdr?: boolean;
+    children: SurfaceBlockSnapshot[];
+} | {
+    blockId: string;
+    kind: "opaque_block";
+    from: number;
+    to: number;
+    fragmentId: string;
+    warningId: string;
+    label: string;
+    detail: string;
+    state: "locked-preserve-only";
+};
+interface SecondaryStorySurface {
+    target: EditorStoryTarget;
+    label: string;
+    storySize: number;
+    blocks: SurfaceBlockSnapshot[];
+}
+interface EditorSurfaceSnapshot {
+    storySize: number;
+    plainText: string;
+    blocks: SurfaceBlockSnapshot[];
+    lockedFragmentIds: string[];
+    secondaryStories: SecondaryStorySurface[];
+}
+type EditorWarningCode = "unsupported_ooxml_preserved" | "unsupported_ooxml_locked" | "import_normalized" | "export_roundtrip_risk" | "comment_anchor_detached" | "revision_anchor_detached" | "large_document_degraded" | "font_substitution" | "image_missing";
+interface EditorWarning {
+    warningId: string;
+    code: EditorWarningCode;
+    severity: "info" | "warning";
+    message: string;
+    source: "import" | "runtime" | "review" | "preservation" | "validation" | "export";
+    affectedAnchor?: EditorAnchorProjection;
+    featureEntryId?: string;
+    details?: Record<string, unknown>;
+}
+type EditorErrorCode = "import_failed" | "export_failed" | "package_corrupt" | "validation_failed" | "datastore_failed" | "internal_invariant";
+interface EditorError {
+    errorId: string;
+    code: EditorErrorCode;
+    message: string;
+    isFatal: boolean;
+    source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
+    details?: Record<string, unknown>;
+}
+type CompatibilityFeatureClass = "supported-roundtrip" | "preserve-only" | "unsupported-fatal";
+interface CompatibilityFeatureEntry {
+    featureEntryId: string;
+    featureKey: string;
+    featureClass: CompatibilityFeatureClass;
+    message: string;
+    affectedAnchor?: EditorAnchorProjection;
+    details?: Record<string, unknown>;
+}
+interface CompatibilityReport {
+    reportVersion: "compatibility-report/1";
+    generatedAt: string;
+    blockExport: boolean;
+    featureEntries: CompatibilityFeatureEntry[];
+    warnings: EditorWarning[];
+    errors: EditorError[];
+}
+interface CompatibilityPanelSnapshot {
+    blockExport: boolean;
+    blockExportReasons: string[];
+    warningCount: number;
+    errorCount: number;
+    featureEntries: CompatibilityFeatureEntry[];
+}
+type ViewMode = "editing" | "review" | "view";
+/**
+ * Runtime document-mode — controls whether editing is unrestricted, restricted
+ * to suggestions, or fully read-only at the document level.
+ *
+ * Distinct from `ViewMode` (editor posture) and `WorkspaceMode` (shell layout).
+ * `DocumentMode` reflects document-level editing authority, not presentation.
+ */
+type DocumentMode = "editing" | "suggesting" | "viewing";
+/**
+ * A single permission range parsed from `w:permStart` / `w:permEnd` in the
+ * source package.  Ranges carry stable ids, edit-rights metadata, and an
+ * enforcement reason that the UI can display.
+ */
+interface ProtectionRange {
+    /** Stable range id from `w:id` on the originating `w:permStart`. */
+    rangeId: string;
+    /** Start offset of the editable range when the runtime can map it safely. */
+    start?: number;
+    /** End offset of the editable range when the runtime can map it safely. */
+    end?: number;
+    /** Editor group allowed to edit this range (`w:edGrp`), if specified. */
+    editorGroup?: string;
+    /** Specific editor identity (`w:ed`), if specified. */
+    editor?: string;
+    /** Whether this range is currently enforced by the runtime. */
+    enforced: boolean;
+    /** Human-readable reason for the enforcement state. */
+    enforcementReason: string;
+}
+/**
+ * Snapshot of the document's protection posture.  Descriptive and bounded —
+ * no public bypass around protected ranges, export blockers, or preserve-only
+ * regions.
+ */
+interface ProtectionSnapshot {
+    /** Whether document-level protection is declared in the source package. */
+    hasDocumentProtection: boolean;
+    /**
+     * The declared protection edit type from `w:documentProtection` in
+     * `settings.xml` (e.g. `"readOnly"`, `"comments"`, `"trackedChanges"`,
+     * `"forms"`, `"none"`).  `undefined` when no protection element exists.
+     */
+    editType?: string;
+    /** Whether the declared protection is enforced (`w:enforcement="1"`). */
+    enforcementActive: boolean;
+    /** All parsed permission ranges from the source package. */
+    ranges: ProtectionRange[];
+    /** Count of permission ranges that are currently enforced. */
+    enforcedRangeCount: number;
+    /** Count of permission ranges preserved but not live-enforced. */
+    preservedRangeCount: number;
+}
+type CaretAffinity = "forward" | "backward" | "none";
+interface ActiveListContext {
+    numberingInstanceId: string;
+    level: number;
+    isOrdered: boolean;
+    markerText?: string;
+}
+interface ActiveNoteContext {
+    noteKind: "footnote" | "endnote";
+    noteId: string;
+    referencePosition: number;
+}
+interface PageRegionHitTest {
+    region: "body" | "header" | "footer" | "margin" | "gutter";
+    sectionIndex: number;
+    columnIndex: number;
+}
+interface LayoutMeasurement {
+    pageRegions: PageRegionHitTest[];
+    caretAffinity: CaretAffinity;
+    tabStops: Array<{
+        pos: number;
+        val?: string;
+        leader?: string;
+    }>;
+    listMarkerLane?: {
+        indent: number;
+        markerWidth: number;
+    };
+    objectFrame?: {
+        kind: "image" | "textbox" | "shape";
+        anchorPos: number;
+        display: "inline" | "floating";
+    };
+}
+interface EditorViewStateSnapshot {
+    viewMode: ViewMode;
+    documentMode: DocumentMode;
+    workspaceMode: WorkspaceMode;
+    zoomLevel: ZoomLevel;
+    activeStory: EditorStoryTarget;
+    selection: SelectionSnapshot;
+    caretAffinity: CaretAffinity;
+    activeListContext: ActiveListContext | null;
+    activeNoteContext: ActiveNoteContext | null;
+    activePageRegion: PageRegionHitTest | null;
+    activeObjectFrame: LayoutMeasurement["objectFrame"] | null;
+    measurement: LayoutMeasurement;
+    isFocused: boolean;
+}
+interface CommandStateSnapshot {
+    canUndo: boolean;
+    canRedo: boolean;
+    readOnly: boolean;
+}
+interface RuntimeRenderSnapshot {
+    documentId: string;
+    sessionId: string;
+    sourceLabel?: string;
+    revisionToken: string;
+    isReady: boolean;
+    isDirty: boolean;
+    readOnly: boolean;
+    documentMode: DocumentMode;
+    selection: SelectionSnapshot;
+    activeStory: EditorStoryTarget;
+    pageLayout?: PageLayoutSnapshot;
+    documentStats: DocumentStats;
+    comments: CommentSidebarSnapshot;
+    trackedChanges: TrackedChangesSnapshot;
+    compatibility: CompatibilityPanelSnapshot;
+    warnings: EditorWarning[];
+    fatalError?: EditorError;
+    commandState: CommandStateSnapshot;
+    surface?: EditorSurfaceSnapshot;
+    protectionSnapshot: ProtectionSnapshot;
+}
+interface EditorSessionState {
+    sessionVersion: "editor-session-state/1";
+    schemaVersion: PersistedEditorSnapshot$1["schemaVersion"];
+    documentId: string;
+    docId: string;
+    createdAt: string;
+    updatedAt: string;
+    editorBuild: string;
+    canonicalDocument: PersistedEditorSnapshot$1["canonicalDocument"];
+    compatibility: CompatibilityReport;
+    warningLog: EditorWarning[];
+    protectionSnapshot?: ProtectionSnapshot;
+    sourcePackage?: PersistedEditorSnapshot$1["sourcePackage"];
+}
+interface PersistedEditorSnapshot {
+    snapshotVersion: PersistedEditorSnapshot$1["snapshotVersion"];
+    schemaVersion: PersistedEditorSnapshot$1["schemaVersion"];
+    documentId: string;
+    docId: string;
+    createdAt: string;
+    updatedAt: string;
+    savedAt: string;
+    editorBuild: string;
+    canonicalDocument: PersistedEditorSnapshot$1["canonicalDocument"];
+    compatibility: CompatibilityReport;
+    warningLog: EditorWarning[];
+    protectionSnapshot?: ProtectionSnapshot;
+    sourcePackage?: PersistedEditorSnapshot$1["sourcePackage"];
+}
+interface AddCommentParams {
+    anchor?: EditorAnchorProjection;
+    body?: string;
+    authorId?: string;
+}
+interface ExportDocxOptions {
+    fileName?: string;
+    reason?: string;
+}
+interface ExportDelivery {
+    mode: "downloaded" | "persisted-by-host" | "exported-bytes-only";
+    savedAt?: string;
+}
+interface ExportResult {
+    bytes: Uint8Array;
+    mimeType: string;
+    fileName: string;
+    delivery: ExportDelivery;
+}
+type WorkflowScopeMode = "edit" | "suggest" | "comment" | "view";
+interface WorkflowCandidateRange {
+    candidateId: string;
+    storyTarget?: EditorStoryTarget;
+    anchor: EditorAnchorProjection;
+    label?: string;
+    source?: "search" | "playbook" | "host" | "ai";
+}
+interface WorkflowScope {
+    scopeId: string;
+    mode: WorkflowScopeMode;
+    anchor: EditorAnchorProjection;
+    storyTarget?: EditorStoryTarget;
+    workItemId?: string;
+    label?: string;
+    domain?: "legal" | "commercial" | "finance" | "other";
+}
+interface WorkflowWorkItem {
+    workItemId: string;
+    title: string;
+    description?: string;
+    domain?: "legal" | "commercial" | "finance" | "other";
+    status?: "pending" | "active" | "done" | "blocked";
+    scopeIds: string[];
+}
+interface WorkflowOverlay {
+    overlayVersion: "workflow-overlay/1";
+    candidates?: WorkflowCandidateRange[];
+    scopes: WorkflowScope[];
+    workItems?: WorkflowWorkItem[];
+    activeWorkItemId?: string | null;
+}
+interface WorkflowBlockedCommandReason {
+    code: "outside_workflow_scope" | "workflow_comment_only" | "workflow_view_only" | "workflow_preserve_only" | "workflow_blocked_import" | "document_read_only" | "document_viewing_mode" | "protected_range" | "unsupported_surface" | "suggesting_unsupported";
+    message: string;
+    scopeId?: string;
+    workItemId?: string;
+    anchor?: EditorAnchorProjection;
+    storyTarget?: EditorStoryTarget;
+}
+interface WorkflowScopeSnapshot {
+    overlayPresent: boolean;
+    activeWorkItemId?: string | null;
+    activeWorkItem?: WorkflowWorkItem;
+    scopes: WorkflowScope[];
+    candidates: WorkflowCandidateRange[];
+    blockedReasons: WorkflowBlockedCommandReason[];
+}
+type EffectiveSelectionMode = WorkflowScopeMode | "blocked";
+interface InteractionGuardSnapshot {
+    effectiveMode: EffectiveSelectionMode;
+    matchedScopeId?: string;
+    matchedScopeMode?: WorkflowScopeMode;
+    disabledReason?: string;
+    blockedReasons: WorkflowBlockedCommandReason[];
+}
+type WorkflowMarkupKind = "highlight" | "comment" | "revision" | "field" | "protected_range" | "opaque_fragment";
+interface WorkflowMarkupBase {
+    markupId: string;
+    kind: WorkflowMarkupKind;
+    anchor: EditorAnchorProjection;
+    storyTarget?: EditorStoryTarget;
+    label: string;
+    excerpt?: string;
+}
+interface WorkflowHighlightMarkup extends WorkflowMarkupBase {
+    kind: "highlight";
+    color: string;
+    text: string;
+}
+interface WorkflowCommentMarkup extends WorkflowMarkupBase {
+    kind: "comment";
+    commentId: string;
+    status: CommentSidebarThreadSnapshot["status"];
+    warningCount: number;
+    entryCount: number;
+    createdAt: string;
+    createdBy: string;
+}
+interface WorkflowRevisionMarkup extends WorkflowMarkupBase {
+    kind: "revision";
+    revisionId: string;
+    revisionKind: TrackedChangeEntrySnapshot["kind"];
+    status: TrackedChangeEntrySnapshot["status"];
+    actionability: TrackedChangeEntrySnapshot["actionability"];
+    authorId: string;
+    createdAt: string;
+    preserveOnlyReason?: string;
+}
+interface WorkflowFieldMarkup extends WorkflowMarkupBase {
+    kind: "field";
+    fieldIndex: number;
+    fieldFamily: FieldFamily;
+    fieldTarget?: string;
+    refreshStatus: FieldRefreshStatus;
+    displayText: string;
+}
+interface WorkflowProtectedRangeMarkup extends WorkflowMarkupBase {
+    kind: "protected_range";
+    rangeId: string;
+    enforced: boolean;
+    enforcementReason: string;
+    editorGroup?: string;
+    editor?: string;
+}
+interface WorkflowOpaqueFragmentMarkup extends WorkflowMarkupBase {
+    kind: "opaque_fragment";
+    fragmentId: string;
+    warningId: string;
+    detail: string;
+    blockedReasonCode: "workflow_preserve_only" | "workflow_blocked_import";
+}
+type WorkflowMarkupItem = WorkflowHighlightMarkup | WorkflowCommentMarkup | WorkflowRevisionMarkup | WorkflowFieldMarkup | WorkflowProtectedRangeMarkup | WorkflowOpaqueFragmentMarkup;
+interface WorkflowMarkupSnapshot {
+    totalCount: number;
+    items: WorkflowMarkupItem[];
+    highlights: WorkflowHighlightMarkup[];
+    comments: WorkflowCommentMarkup[];
+    revisions: WorkflowRevisionMarkup[];
+    fields: WorkflowFieldMarkup[];
+    protectedRanges: WorkflowProtectedRangeMarkup[];
+    opaqueFragments: WorkflowOpaqueFragmentMarkup[];
+}
+type HostAnnotationKind = "note" | "scope_hint" | "readonly_marker" | "suggestion" | "warning";
+interface HostAnnotationItem {
+    annotationId: string;
+    kind: HostAnnotationKind;
+    label: string;
+    anchor: EditorAnchorProjection;
+    storyTarget?: EditorStoryTarget;
+    detail?: string;
+    scopeMode?: WorkflowScopeMode;
+    severity?: "low" | "medium" | "high";
+    workItemId?: string;
+    provenance: "host";
+}
+interface HostAnnotationOverlay {
+    overlayVersion: "host-annotation-overlay/1";
+    annotations: HostAnnotationItem[];
+}
+interface HostAnnotationSnapshot {
+    totalCount: number;
+    annotations: HostAnnotationItem[];
+}
+interface WorkflowCandidateRangeOptions {
+    kinds?: WorkflowMarkupKind[];
+    includeDetached?: boolean;
+    source?: WorkflowCandidateRange["source"];
+}
+type AutosaveState = {
+    status: "idle";
+} | {
+    status: "saving";
+} | {
+    status: "saved";
+    savedAt: string;
+} | {
+    status: "error";
+    error: EditorError;
+};
+interface AutosaveConfig {
+    enabled?: boolean;
+    debounceMs?: number;
+}
+type WordReviewEditorEvent = {
+    type: "ready";
+    documentId: string;
+    sessionId: string;
+    source: "docx" | "session" | "snapshot";
+    stats: DocumentStats;
+    compatibility: CompatibilityReport;
+    comments: CommentSidebarSnapshot;
+    trackedChanges: TrackedChangesSnapshot;
+} | {
+    type: "dirty_changed";
+    documentId: string;
+    isDirty: boolean;
+} | {
+    type: "selection_changed";
+    documentId: string;
+    selection: SelectionSnapshot;
+} | {
+    type: "comment_added";
+    documentId: string;
+    commentId: string;
+    anchor: EditorAnchorProjection;
+} | {
+    type: "comment_resolved";
+    documentId: string;
+    commentId: string;
+} | {
+    type: "change_accepted";
+    documentId: string;
+    changeId: string;
+} | {
+    type: "change_rejected";
+    documentId: string;
+    changeId: string;
+} | {
+    type: "story_changed";
+    documentId: string;
+    activeStory: EditorStoryTarget;
+} | {
+    type: "warning_added";
+    documentId: string;
+    warning: EditorWarning;
+} | {
+    type: "warning_cleared";
+    documentId: string;
+    warningId: string;
+    code: EditorWarningCode;
+} | {
+    type: "error";
+    documentId: string;
+    error: EditorError;
+} | {
+    type: "autosave_state";
+    documentId: string;
+    state: AutosaveState;
+} | {
+    type: "snapshot_saved";
+    documentId: string;
+    snapshot: PersistedEditorSnapshot;
+    isAutosave: boolean;
+} | {
+    type: "session_saved";
+    documentId: string;
+    sessionState: EditorSessionState;
+    savedAt: string;
+    isAutosave: boolean;
+} | {
+    type: "export_completed";
+    documentId: string;
+    result: ExportResult;
+} | {
+    type: "workflow_overlay_changed";
+    documentId: string;
+    snapshot: WorkflowScopeSnapshot;
+} | {
+    type: "workflow_active_work_item_changed";
+    documentId: string;
+    activeWorkItemId: string | null;
+} | {
+    type: "host_annotation_overlay_changed";
+    documentId: string;
+    snapshot: HostAnnotationSnapshot;
+} | {
+    type: "change_authored";
+    documentId: string;
+    changeId: string;
+    kind: "insertion" | "deletion";
+} | {
+    type: "command_blocked";
+    documentId: string;
+    command: string;
+    reasons: WorkflowBlockedCommandReason[];
+};
+interface LoadResult {
+    source?: ExternalDocumentSource;
+}
+interface SaveSnapshotParams {
+    documentId: string;
+    snapshot: PersistedEditorSnapshot;
+    isAutosave: boolean;
+}
+interface SaveSnapshotResult {
+    savedAt: string;
+}
+interface SaveSessionParams {
+    documentId: string;
+    sessionState: EditorSessionState;
+    isAutosave: boolean;
+}
+interface SaveSessionResult {
+    savedAt: string;
+}
+interface SaveExportParams {
+    documentId: string;
+    result: ExportResult;
+}
+interface SaveExportResult {
+    savedAt: string;
+}
+interface EditorTelemetryEvent {
+    type: string;
+    documentId: string;
+    detail?: Record<string, unknown>;
+}
+interface EditorHostAdapter {
+    load?(params: LoadRequest): Promise<LoadResult>;
+    saveSession?(params: SaveSessionParams): Promise<SaveSessionResult>;
+    saveExport?(params: SaveExportParams): Promise<SaveExportResult>;
+    logEvent?(event: EditorTelemetryEvent): void;
+}
+interface EditorDatastoreAdapter {
+    load(params: LoadRequest): Promise<LoadResult>;
+    saveSnapshot(params: SaveSnapshotParams): Promise<SaveSnapshotResult>;
+    saveExport?(params: SaveExportParams): Promise<SaveExportResult>;
+    logEvent?(event: EditorTelemetryEvent): void;
+}
+interface WordReviewEditorRef {
+    focus(): void;
+    blur(): void;
+    undo(): void;
+    redo(): void;
+    addComment(params: AddCommentParams): string;
+    openComment(commentId: string): void;
+    resolveComment(commentId: string): void;
+    reopenComment(commentId: string): void;
+    addCommentReply(commentId: string, body: string): void;
+    editCommentBody(commentId: string, body: string): void;
+    deleteComment(commentId: string): void;
+    acceptChange(changeId: string): void;
+    rejectChange(changeId: string): void;
+    acceptAllChanges(): void;
+    rejectAllChanges(): void;
+    exportDocx(options?: ExportDocxOptions): Promise<ExportResult>;
+    getSessionState(): EditorSessionState;
+    getSnapshot(): PersistedEditorSnapshot;
+    getRenderSnapshot(): RuntimeRenderSnapshot;
+    getCompatibilityReport(): CompatibilityReport;
+    getWarnings(): EditorWarning[];
+    getCommentSidebarSnapshot(): CommentSidebarSnapshot;
+    getTrackedChangesSnapshot(): TrackedChangesSnapshot;
+    getComments(): CommentSidebarSnapshot;
+    getTrackedChanges(): TrackedChangesSnapshot;
+    isDirty(): boolean;
+    getFormattingState(): FormattingStateSnapshot;
+    getStyleCatalog(): StyleCatalogSnapshot;
+    replaceText(text: string, target?: EditorAnchorProjection): void;
+    toggleBold(): void;
+    toggleItalic(): void;
+    toggleUnderline(): void;
+    toggleStrikethrough(): void;
+    toggleSuperscript(): void;
+    toggleSubscript(): void;
+    setFontFamily(fontFamily: string | null): void;
+    setFontSize(size: number | null): void;
+    setTextColor(color: string | null): void;
+    setHighlightColor(color: string | null): void;
+    setAlignment(alignment: FormattingAlignment): void;
+    setParagraphStyle(styleId: string | null): void;
+    setTableStyle(styleId: string | null): void;
+    indent(): void;
+    outdent(): void;
+    insertPageBreak(): void;
+    insertTable(options: InsertTableOptions): void;
+    insertImage(options: InsertImageOptions): void;
+    addRowBefore(): void;
+    addRowAfter(): void;
+    addColumnBefore(): void;
+    addColumnAfter(): void;
+    deleteRow(): void;
+    deleteColumn(): void;
+    deleteTable(): void;
+    mergeCells(): void;
+    splitCell(): void;
+    setCellBackground(color: string): void;
+    search(query: string, options?: SearchOptions): SearchResultSnapshot[];
+    clearSearch(): void;
+    setSelection(selection: SelectionSnapshot | null): void;
+    scrollToRevision(revisionId: string): void;
+    scrollToComment(commentId: string): void;
+    openStory(target: EditorStoryTarget): void;
+    closeStory(): void;
+    getPageLayoutSnapshot(): PageLayoutSnapshot | null;
+    getDocumentNavigationSnapshot(): DocumentNavigationSnapshot;
+    getFieldSnapshot(): FieldSnapshot;
+    updateFields(options?: UpdateFieldsOptions): UpdateFieldsResult;
+    updateTableOfContents(options?: TocRefreshOptions): TocRefreshResult;
+    getViewState(): EditorViewStateSnapshot;
+    setDocumentMode(mode: DocumentMode): void;
+    getProtectionSnapshot(): ProtectionSnapshot;
+    setWorkspaceMode(mode: WorkspaceMode): void;
+    setZoom(level: ZoomLevel): void;
+    insertSectionBreak(type: SectionBreakType, options?: {
+        afterSectionIndex?: number;
+    }): void;
+    deleteSectionBreak(sectionIndex: number): void;
+    updateSectionLayout(sectionIndex: number, patch: SectionLayoutPatch): void;
+    setSectionPageNumbering(sectionIndex: number, patch: SectionPageNumberingPatch | null): void;
+    setHeaderFooterLink(sectionIndex: number, params: HeaderFooterLinkPatch): void;
+    setImageLayout(mediaId: string, dimensions: {
+        widthEmu: number;
+        heightEmu: number;
+    }): void;
+    setImageFrame(mediaId: string, offsets: {
+        horizontalOffsetEmu?: number;
+        verticalOffsetEmu?: number;
+    }): void;
+    setWorkflowOverlay(overlay: WorkflowOverlay): void;
+    clearWorkflowOverlay(): void;
+    getWorkflowScopeSnapshot(): WorkflowScopeSnapshot | null;
+    getInteractionGuardSnapshot(): InteractionGuardSnapshot;
+    getWorkflowMarkupSnapshot(): WorkflowMarkupSnapshot;
+    setHostAnnotationOverlay(overlay: HostAnnotationOverlay): void;
+    clearHostAnnotationOverlay(): void;
+    getHostAnnotationSnapshot(): HostAnnotationSnapshot;
+    getWorkflowCandidateRanges(options?: WorkflowCandidateRangeOptions): WorkflowCandidateRange[];
+    replaceWorkflowMarkupText(markupId: string, text: string): void;
+}
+interface WordReviewEditorProps {
+    documentId: string;
+    currentUser: EditorUser;
+    initialDocx?: Uint8Array | ArrayBuffer;
+    initialSessionState?: EditorSessionState;
+    initialSnapshot?: PersistedEditorSnapshot;
+    initialSourceLabel?: string;
+    externalDocumentRevision?: string;
+    externalDocSource?: ExternalDocumentSource;
+    loadRevision?: string;
+    loadSourcePolicy?: LoadSourcePolicy;
+    readOnly?: boolean;
+    reviewMode?: "editing" | "review";
+    suggestionsEnabled?: boolean;
+    markupDisplay?: "clean" | "simple" | "all";
+    showReviewPanel?: boolean;
+    chromeVisibility?: Partial<WordReviewEditorChromeVisibility>;
+    hostAdapter?: EditorHostAdapter;
+    datastore?: EditorDatastoreAdapter;
+    autosave?: AutosaveConfig;
+    onEvent?: (event: WordReviewEditorEvent) => void;
+    onWarning?: (warning: EditorWarning) => void;
+    onError?: (error: EditorError) => void;
+}
+interface WordReviewEditorChromeVisibility {
+    toolbar: boolean;
+    alerts: boolean;
+    selectionOverlay: boolean;
+    contextToolbars: boolean;
+    pageChrome: boolean;
+    statusBar: boolean;
+    reviewRail: boolean;
+}
+
+export { type SaveSessionResult as $, type ActiveListContext as A, type EditorWarning as B, type CaretAffinity as C, type DocumentHeadingSnapshot as D, type EditorSessionState as E, type EditorWarningCode as F, type ExportDocxOptions as G, type ExportResult as H, type ExternalDocumentSource as I, type HeaderFooterLinkPatch as J, type HostAnnotationItem as K, type HostAnnotationKind as L, type HostAnnotationOverlay as M, type HostAnnotationSnapshot as N, type InteractionGuardSnapshot as O, type PersistedEditorSnapshot as P, type LayoutMeasurement as Q, type LoadRequest as R, type LoadResult as S, type LoadSourcePolicy as T, type PageLayoutSnapshot as U, type PageRegionHitTest as V, type WordReviewEditorProps as W, type RuntimeRenderSnapshot as X, type SaveExportParams as Y, type SaveExportResult as Z, type SaveSessionParams as _, type WordReviewEditorRef as a, type MappingResult as a$, type SaveSnapshotParams as a0, type SaveSnapshotResult as a1, type SectionBreakType as a2, type SectionLayoutPatch as a3, type SectionPageNumberingPatch as a4, type SelectionSnapshot as a5, type StyleCatalogEntrySnapshot as a6, type StyleCatalogSnapshot as a7, type SurfaceBlockSnapshot as a8, type SurfaceInlineSegment as a9, type WorkspaceMode as aA, type ZoomLevel as aB, type FormattingAlignment as aC, type InsertImageOptions as aD, type FormattingStateSnapshot as aE, type ProtectionSnapshot as aF, type SelectionSnapshot$1 as aG, type CanonicalDocumentEnvelope as aH, type TransactionMapping as aI, type EditorWarning$1 as aJ, type CommentThreadRecord as aK, type DocumentMode as aL, type FieldSnapshot as aM, type UpdateFieldsOptions as aN, type UpdateFieldsResult as aO, type TocRefreshOptions as aP, type TocRefreshResult as aQ, type InsertTableOptions as aR, type SearchOptions as aS, type SecondaryStorySurface as aT, type Assoc as aU, type BoundaryAssoc as aV, DEFAULT_BOUNDARY_ASSOC as aW, type DetachedAnchor as aX, type DocRange as aY, type EditorAnchorProjection$1 as aZ, MAIN_STORY_TARGET as a_, type SurfaceTableCellSnapshot as aa, type SurfaceTableRowSnapshot as ab, type SurfaceTextMark as ac, type TrackedChangeEntrySnapshot as ad, type TrackedChangesSnapshot as ae, type ViewMode as af, type WordReviewEditorChromeVisibility as ag, type WordReviewEditorEvent as ah, type WorkflowBlockedCommandReason as ai, type WorkflowCandidateRange as aj, type WorkflowCandidateRangeOptions as ak, type WorkflowCommentMarkup as al, type WorkflowFieldMarkup as am, type WorkflowHighlightMarkup as an, type WorkflowMarkupBase as ao, type WorkflowMarkupItem as ap, type WorkflowMarkupKind as aq, type WorkflowMarkupSnapshot as ar, type WorkflowOpaqueFragmentMarkup as as, type WorkflowOverlay as at, type WorkflowProtectedRangeMarkup as au, type WorkflowRevisionMarkup as av, type WorkflowScope as aw, type WorkflowScopeMode as ax, type WorkflowScopeSnapshot as ay, type WorkflowWorkItem as az, type ActiveNoteContext as b, type MappingStep as b0, type NodeAnchor as b1, type Position as b2, type RangeAnchor as b3, areAnchorsEqual as b4, createDetachedAnchor as b5, createEmptyMapping as b6, createNodeAnchor as b7, createRangeAnchor as b8, getEffectiveRange as b9, createCanonicalDocumentId as bA, createDefaultCanonicalDocument as bB, createEditorState as bC, createEmptyCompatibilityReport as bD, createEmptyReviewStore as bE, createPersistedEditorSnapshot as bF, createSelectionSnapshot as bG, deriveDocumentStats as bH, deriveRenderSnapshot as bI, normalizeCommentThreadRecord as bJ, type EffectiveSelectionMode as bK, type ExportDelivery as bL, type FieldEntrySnapshot as bM, type FieldFamily as bN, type FieldRefreshStatus as bO, type FormattingBreadcrumbItem as bP, type ProtectionRange as bQ, type SearchResultSnapshot as bR, type SupportedFieldFamily as bS, mapAnchor as ba, mapPosition as bb, mapRange as bc, normalizeRange as bd, storyTargetsEqual as be, type CommandStateSnapshot$1 as bf, type CommentEntryRecord as bg, type CommentResolutionRecord as bh, type CommentSidebarSnapshot$1 as bi, type CompatibilityFeatureClass$1 as bj, type CompatibilityFeatureEntry$1 as bk, type CompatibilityPanelSnapshot$1 as bl, type CompatibilityReport$1 as bm, type CreateEditorStateOptions as bn, type DocumentStats$1 as bo, type EditorError$1 as bp, type EditorRuntimeState as bq, type EditorState as br, type EditorWarningCode$1 as bs, type PersistedEditorSnapshot$1 as bt, type ReviewStore as bu, type RevisionMetadataRecord as bv, type RevisionRecord as bw, type RuntimePhase as bx, type RuntimeRenderSnapshot$1 as by, type TrackedChangesSnapshot$1 as bz, type AddCommentParams as c, type AutosaveConfig as d, type AutosaveState as e, type CommandStateSnapshot as f, type CommentSidebarSnapshot as g, type CommentSidebarThreadEntrySnapshot as h, type CommentSidebarThreadSnapshot as i, type CompatibilityFeatureClass as j, type CompatibilityFeatureEntry as k, type CompatibilityPanelSnapshot as l, type CompatibilityReport as m, type DocumentNavigationSnapshot as n, type DocumentPageSnapshot as o, type DocumentStats as p, type EditorAnchorProjection as q, type EditorDatastoreAdapter as r, type EditorError as s, type EditorErrorCode as t, type EditorHostAdapter as u, type EditorStoryTarget as v, type EditorSurfaceSnapshot as w, type EditorTelemetryEvent as x, type EditorUser as y, type EditorViewStateSnapshot as z };