@arbidocs/blocks 0.5.107 → 0.5.108

package/node_modules/@docx-editor.dev/core/dist/{types-barrel-D3xCgQX6.d.ts → types-barrel-DuC5QBNC.d.ts}

@@ -1,4 +1,4 @@
-import { c as HistoryGroupOutcome } from './editor-scope-OHPwVQ5l.js';
+import { c as HistoryGroupOutcome } from './editor-scope-7o9xweiJ.js';
 
 /**
  * How a tracked change is addressed: `@w:id`, `@w:author` and `@w:date` together, within a
@@ -1072,56 +1072,6 @@ interface InsertBuildingBlockOp {
     readonly blocks: readonly OoxmlNode[];
 }
 
-/**
- * Why a zip was refused at the trust boundary.
- *
- * `too-large` and `too-many-entries` are the zip-bomb guards; `bad-name` catches path traversal —
- * an entry with `..` or a leading `/` is rejected rather than normalized.
- */
-type ZipRejection = 'too-many-entries' | 'too-large' | 'bad-name' | 'inflate-error';
-/** Archive caps: entry count, total decompressed bytes, and the decompression ratio. */
-interface ZipLimits {
-    readonly maxEntries: number;
-    /** Max total UNCOMPRESSED bytes across the archive. */
-    readonly maxTotalBytes: number;
-    /**
-     * Max ratio of the archive's total declared uncompressed bytes to the archive's own byte
-     * length (zip-bomb guard). Applies once that total exceeds 8 MiB, so a small archive is
-     * never refused for compressing well.
-     */
-    readonly maxRatio?: number;
-}
-/** The archive caps in force when a host configures none. Conservative and finite. */
-declare const DEFAULT_ZIP_LIMITS: ZipLimits;
-/** The read entries, or the typed refusal. Never throws — the bytes are untrusted. */
-type ZipReadResult = {
-    readonly ok: true;
-    readonly entries: ReadonlyMap<string, Uint8Array>;
-} | {
-    readonly ok: false;
-    readonly reason: ZipRejection;
-    readonly detail?: string;
-    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
-};
-/**
- * Inflate a ZIP archive with bounds + OPC name normalization. Entry name, count, archive
- * ratio, and total-uncompressed-size limits are enforced BEFORE each entry is decompressed
- * (via fflate's pre-inflation filter), so a zip bomb or a traversal name is rejected without
- * ever being inflated. Keys are canonical part names.
- *
- * The budgets count each entry's DECLARED sizes, and the declared size is also a hard cap on
- * what the entry may produce: fflate inflates into a buffer of exactly `originalSize` bytes
- * and never grows it, so an entry whose stream holds more than it declares is truncated (or
- * refused as `inflate-error`), never expanded past its budget. A stored entry is copied at
- * its compressed size, so the larger of its two declared sizes is what counts.
- */
-declare function readZip(bytes: Uint8Array, limits?: ZipLimits): ZipReadResult;
-/** Deflate a set of canonical-part-name -> bytes into a ZIP archive. Every part name
- *  is re-validated through the OPC normalization profile before writing, so a
- *  traversal/encoded/normalized-alias name from an untrusted serialized model can
- *  never be smuggled into a ZIP entry (write-side path-traversal guard). */
-declare function writeZip(entries: ReadonlyMap<string, Uint8Array>): Uint8Array;
-
 /**
  * Why a part or relationship name was refused.
  *
@@ -1260,91 +1210,6 @@ type ImageRelationshipResolution = {
  */
 declare function resolveImageRelationship(records: readonly RelationshipRecord[] | undefined, ownerPart: string, relationshipId: string): ImageRelationshipResolution;
 
-/** One `<Default>`: a file extension mapped to a content type. */
-interface DefaultRecord {
-    readonly extension: string;
-    readonly contentType: string;
-    readonly order: number;
-}
-/** One `<Override>`: a specific part name mapped to a content type. Beats any Default. */
-interface OverrideRecord {
-    readonly partName: string;
-    readonly contentType: string;
-    readonly order: number;
-}
-/**
- * The authored `[Content_Types].xml` records, in significant order.
- *
- * Retained rather than collapsed into a lookup, because the file's lexical form and ordering are
- * part of what a lossless save re-emits.
- */
-interface ContentTypeRecords {
-    readonly defaults: readonly DefaultRecord[];
-    readonly overrides: readonly OverrideRecord[];
-}
-/**
- * Why content-type records could not be indexed.
- *
- * All fail CLOSED: conflicting Defaults on one extension, duplicate normalized Override names, or
- * invalid MIME syntax are refused rather than resolved by picking one.
- */
-type ContentTypeError = {
-    readonly code: 'invalid-mime';
-    readonly value: string;
-} | {
-    readonly code: 'conflicting-default';
-    readonly extension: string;
-} | {
-    readonly code: 'duplicate-override';
-    readonly partName: string;
-} | {
-    readonly code: 'invalid-override-name';
-    readonly partName: string;
-} | {
-    readonly code: 'too-many-records';
-    readonly limit: number;
-};
-/** Whether a string is syntactically a MIME type. Syntax only — no registry lookup. */
-declare function isValidMime(value: string): boolean;
-/** ASCII-case-insensitive extension key (leading dot removed; ASCII-only fold). */
-declare function extensionKey(extension: string): string;
-/** The resolved lookup: Override by case-folded part name, Default by case-insensitive extension. */
-interface ContentTypeIndex {
-    /** ext key -> single MIME (identical duplicates collapsed). */
-    readonly defaults: ReadonlyMap<string, string>;
-    /** case-folded part name -> MIME. */
-    readonly overrides: ReadonlyMap<string, string>;
-}
-/** The built index, or the conflict that made it impossible. */
-type IndexResult = {
-    readonly ok: true;
-    readonly index: ContentTypeIndex;
-} | {
-    readonly ok: false;
-    readonly error: ContentTypeError;
-};
-/**
- * Build a resolved content-type index, failing closed on conflict/duplicate/MIME
- * errors. `maxRecords` bounds the combined record count (N/N+1 gate).
- */
-declare function buildContentTypeIndex(records: ContentTypeRecords, maxRecords?: number): IndexResult;
-/**
- * A part's content type, or why it has none.
- *
- * An orphan record never determines a part's type — a Default with no matching part is preserved
- * inertly rather than applied.
- */
-type ResolveResult = {
-    readonly ok: true;
-    readonly contentType: string;
-    readonly source: 'override' | 'default';
-} | {
-    readonly ok: false;
-    readonly reason: 'unknown';
-};
-/** Resolve a part's content type: Override wins over Default; else unknown. */
-declare function resolveContentType(index: ContentTypeIndex, partName: string): ResolveResult;
-
 type ShapeSchemeColorResolver = (scheme: string) => string | null;
 type ShapeStyleMatrixResolver = (kind: 'fill' | 'line', index: number) => OoxmlElement | null;
 /**
@@ -1612,80 +1477,303 @@ interface GroupPictureProjection {
 }
 
 /**
- * Whether a drawing sits in the text flow or is positioned against a frame.
+ * Why a zip was refused at the trust boundary.
  *
- * The distinction that decides everything downstream: an inline drawing occupies a character
- * position, while an anchored one has offsets relative to a page, margin or column.
+ * `too-large` and `too-many-entries` are the zip-bomb guards; `bad-name` catches path traversal —
+ * an entry with `..` or a leading `/` is rejected rather than normalized.
  */
-type DrawingKind = 'inline' | 'anchored';
-/** Nine Word wrap menu targets (inline plus eight floating modes). @public */
-type ImageWrapTarget = 'inline' | 'square' | 'squareLeft' | 'squareRight' | 'tight' | 'through' | 'topAndBottom' | 'behind' | 'inFront';
-/** Every text-wrap mode a drawing may be set to, including `inline`. */
-declare const IMAGE_WRAP_TARGETS: readonly ImageWrapTarget[];
-type DrawingWrapElement = 'none' | 'square' | 'tight' | 'through' | 'topAndBottom';
-type DrawingHorizontalReferenceFrame = 'character' | 'column' | 'insideMargin' | 'leftMargin' | 'margin' | 'outsideMargin' | 'page' | 'rightMargin';
-type DrawingVerticalReferenceFrame = 'bottomMargin' | 'insideMargin' | 'line' | 'margin' | 'outsideMargin' | 'page' | 'paragraph' | 'topMargin';
-/** `a:srcRect` — how much of each edge of the source image is cropped away, as fractions. */
-interface SourceCrop {
-    readonly left: number;
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
-}
-interface DrawingTransform {
-    readonly rotationDegrees: number;
-    readonly flipHorizontal: boolean;
-    readonly flipVertical: boolean;
-    /** Source `a:off` in EMU; defaults to origin when absent. */
-    readonly offsetEmu: Readonly<{
-        x: number;
-        y: number;
-    }>;
-    /** Source `a:ext` in EMU; zero falls back to `wp:extent` at geometry time. */
-    readonly extentEmu: Readonly<{
-        cx: number;
-        cy: number;
-    }>;
+type ZipRejection = 'too-many-entries' | 'too-large' | 'bad-name' | 'inflate-error';
+/** Archive caps: entry count, total decompressed bytes, and the decompression ratio. */
+interface ZipLimits {
+    readonly maxEntries: number;
+    /** Max total UNCOMPRESSED bytes across the archive. */
+    readonly maxTotalBytes: number;
+    /**
+     * Max ratio of the archive's total declared uncompressed bytes to the archive's own byte
+     * length (zip-bomb guard). Applies once that total exceeds 8 MiB, so a small archive is
+     * never refused for compressing well.
+     */
+    readonly maxRatio?: number;
 }
+/** The archive caps in force when a host configures none. Conservative and finite. */
+declare const DEFAULT_ZIP_LIMITS: ZipLimits;
+/** The read entries, or the typed refusal. Never throws — the bytes are untrusted. */
+type ZipReadResult = {
+    readonly ok: true;
+    readonly entries: ReadonlyMap<string, Uint8Array>;
+} | {
+    readonly ok: false;
+    readonly reason: ZipRejection;
+    readonly detail?: string;
+    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
+};
 /**
- * What a drawing refuses: selection, movement, resizing, aspect change.
+ * Inflate a ZIP archive with bounds + OPC name normalization. Entry name, count, archive
+ * ratio, and total-uncompressed-size limits are enforced BEFORE each entry is decompressed
+ * (via fflate's pre-inflation filter), so a zip bomb or a traversal name is rejected without
+ * ever being inflated. Keys are canonical part names.
  *
- * Read and honoured rather than advisory — chrome that offered a handle the store will refuse
- * would promise an edit that cannot happen.
+ * The budgets count each entry's DECLARED sizes, and the declared size is also a hard cap on
+ * what the entry may produce: fflate inflates into a buffer of exactly `originalSize` bytes
+ * and never grows it, so an entry whose stream holds more than it declares is truncated (or
+ * refused as `inflate-error`), never expanded past its budget. A stored entry is copied at
+ * its compressed size, so the larger of its two declared sizes is what counts.
  */
-interface DrawingLocks {
-    readonly select: boolean;
-    readonly move: boolean;
-    readonly resize: boolean;
-    readonly changeAspect: boolean;
+declare function readZip(bytes: Uint8Array, limits?: ZipLimits): ZipReadResult;
+/** Deflate a set of canonical-part-name -> bytes into a ZIP archive. Every part name
+ *  is re-validated through the OPC normalization profile before writing, so a
+ *  traversal/encoded/normalized-alias name from an untrusted serialized model can
+ *  never be smuggled into a ZIP entry (write-side path-traversal guard). */
+declare function writeZip(entries: ReadonlyMap<string, Uint8Array>): Uint8Array;
+
+/** One `<Default>`: a file extension mapped to a content type. */
+interface DefaultRecord {
+    readonly extension: string;
+    readonly contentType: string;
+    readonly order: number;
 }
-interface DrawingLocksInput {
-    readonly select?: boolean;
-    readonly move?: boolean;
-    readonly resize?: boolean;
-    readonly changeAspect?: boolean;
+/** One `<Override>`: a specific part name mapped to a content type. Beats any Default. */
+interface OverrideRecord {
+    readonly partName: string;
+    readonly contentType: string;
+    readonly order: number;
 }
 /**
- * An anchored drawing's position: offsets, and the frames they are relative to.
+ * The authored `[Content_Types].xml` records, in significant order.
  *
- * The relative-to bases matter as much as the offsets. Writing an offset without preserving its
- * base re-anchors the drawing against a different reference and moves it somewhere nobody asked.
+ * Retained rather than collapsed into a lookup, because the file's lexical form and ordering are
+ * part of what a lossless save re-emits.
  */
-interface DrawingPositionInput {
-    /**
-     * `'simple'` when `@simplePos="1"`: `horizontalEmu` / `verticalEmu` are authoritative
-     * `wp:simplePos` x/y. `'frame'` (default) uses positionH/V relative frames.
-     */
-    readonly mode?: 'frame' | 'simple';
-    readonly horizontalEmu?: number;
-    readonly verticalEmu?: number;
-    readonly relativeToH?: DrawingHorizontalReferenceFrame;
-    readonly relativeToV?: DrawingVerticalReferenceFrame;
+interface ContentTypeRecords {
+    readonly defaults: readonly DefaultRecord[];
+    readonly overrides: readonly OverrideRecord[];
 }
-interface DrawingProjection {
-    readonly drawingNodeId: string;
-    readonly ownerPartName: string;
-    readonly kind: DrawingKind;
+/**
+ * Why content-type records could not be indexed.
+ *
+ * All fail CLOSED: conflicting Defaults on one extension, duplicate normalized Override names, or
+ * invalid MIME syntax are refused rather than resolved by picking one.
+ */
+type ContentTypeError = {
+    readonly code: 'invalid-mime';
+    readonly value: string;
+} | {
+    readonly code: 'conflicting-default';
+    readonly extension: string;
+} | {
+    readonly code: 'duplicate-override';
+    readonly partName: string;
+} | {
+    readonly code: 'invalid-override-name';
+    readonly partName: string;
+} | {
+    readonly code: 'too-many-records';
+    readonly limit: number;
+};
+/** Whether a string is syntactically a MIME type. Syntax only — no registry lookup. */
+declare function isValidMime(value: string): boolean;
+/** ASCII-case-insensitive extension key (leading dot removed; ASCII-only fold). */
+declare function extensionKey(extension: string): string;
+/** The resolved lookup: Override by case-folded part name, Default by case-insensitive extension. */
+interface ContentTypeIndex {
+    /** ext key -> single MIME (identical duplicates collapsed). */
+    readonly defaults: ReadonlyMap<string, string>;
+    /** case-folded part name -> MIME. */
+    readonly overrides: ReadonlyMap<string, string>;
+}
+/** The built index, or the conflict that made it impossible. */
+type IndexResult = {
+    readonly ok: true;
+    readonly index: ContentTypeIndex;
+} | {
+    readonly ok: false;
+    readonly error: ContentTypeError;
+};
+/**
+ * Build a resolved content-type index, failing closed on conflict/duplicate/MIME
+ * errors. `maxRecords` bounds the combined record count (N/N+1 gate).
+ */
+declare function buildContentTypeIndex(records: ContentTypeRecords, maxRecords?: number): IndexResult;
+/**
+ * A part's content type, or why it has none.
+ *
+ * An orphan record never determines a part's type — a Default with no matching part is preserved
+ * inertly rather than applied.
+ */
+type ResolveResult = {
+    readonly ok: true;
+    readonly contentType: string;
+    readonly source: 'override' | 'default';
+} | {
+    readonly ok: false;
+    readonly reason: 'unknown';
+};
+/** Resolve a part's content type: Override wins over Default; else unknown. */
+declare function resolveContentType(index: ContentTypeIndex, partName: string): ResolveResult;
+
+/** Caps applied while loading a package: zip, XML, part count and relationship count. */
+interface OoxmlPackageLimits {
+    readonly zip?: ZipLimits;
+    readonly xml?: XmlLimits;
+    /** Cap on parts converted into canonical trees (N/N+1 gate, not a soft target). */
+    readonly maxXmlParts?: number;
+    /** Cap on relationship records across every rels part. */
+    readonly maxRelationships?: number;
+}
+/** The limits in force when a host configures none. Conservative and finite. */
+declare const DEFAULT_OOXML_PACKAGE_LIMITS: Required<Pick<OoxmlPackageLimits, 'maxXmlParts' | 'maxRelationships'>>;
+/**
+ * An external relationship target. Retained verbatim as authored evidence, with the
+ * sink-safety verdict alongside it. Never resolved against the package, never fetched.
+ */
+interface OoxmlExternalTarget {
+    readonly ownerPart: string;
+    readonly id: string;
+    readonly type: string;
+    readonly rawTarget: string;
+    /** False when the target is not a safe sink (javascript:, file:, ...). Still not fetched. */
+    readonly sinkSafe: boolean;
+}
+/**
+ * A loaded package: every XML part as a canonical tree, plus the non-XML parts kept verbatim.
+ *
+ * The preservation model in one value. Modelled parts re-emit normalized; everything else is
+ * byte-identical, which is why an unrecognized part never costs a document anything.
+ */
+interface OoxmlPackage {
+    /** Canonical trees, keyed by canonical part name. Non-XML parts are absent by design. */
+    readonly parts: ReadonlyMap<string, OoxmlPart>;
+    /** Raw bytes of every entry, including the non-XML parts that have no tree. */
+    readonly partBytes: ReadonlyMap<string, Uint8Array>;
+    /** Internal relationships by owner part, in authored order. */
+    readonly relationships: ReadonlyMap<string, readonly RelationshipRecord[]>;
+    readonly externalTargets: readonly OoxmlExternalTarget[];
+    readonly contentTypes: ContentTypeIndex;
+    /** Canonical name of the part the root `officeDocument` relationship points at. */
+    readonly mainDocumentPart: string;
+}
+/** Why a package could not be loaded. Every code describes the FILE, not the caller. */
+type OoxmlPackageRejection = ZipRejection | OoxmlReadRejection | 'no-content-types' | 'bad-content-types' | 'no-main-document' | 'bad-relationship-target' | 'duplicate-relationship-id' | 'too-many-relationships' | 'too-many-xml-parts';
+/** A loaded package, or a typed refusal. Never throws. */
+type OoxmlPackageResult = {
+    readonly ok: true;
+    readonly package: OoxmlPackage;
+} | {
+    readonly ok: false;
+    readonly reason: OoxmlPackageRejection;
+    readonly detail?: string;
+    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
+};
+/**
+ * Load DOCX bytes into canonical typed/generic OOXML trees, bounded at every step.
+ *
+ * THE trust boundary for a document. Composes the hardened primitives — zip limits and OPC name
+ * normalization, content-type indexing, relationship validation, entity-free XML — into one
+ * loader, and returns a typed rejection rather than throwing from inside a decoder.
+ *
+ * Fails closed on every limit, malformed name, unresolvable internal target, duplicate
+ * relationship id, and XML rejection. An external relationship never causes a failure and
+ * never causes a fetch: it is recorded with its sink-safety verdict for a later, explicitly
+ * user-gated lane. A content-type record with an invalid MIME type is treated as absent,
+ * unless it decides the type of the main document part, a relationships part, or a
+ * non-payload part that the package root or the main document relates to.
+ */
+declare function readOoxmlPackage(bytes: Uint8Array, limits?: OoxmlPackageLimits): OoxmlPackageResult;
+/**
+ * Serialize a canonical package back to DOCX bytes.
+ *
+ * Starts from the ORIGINAL entry bytes and overwrites only the parts held as trees. A part
+ * the loader did not model — media, fonts, an XML part outside the modeled set — passes
+ * through untouched, so round-tripping a document cannot lose a part the engine never
+ * claimed to understand.
+ *
+ * The modeled parts are re-emitted NORMALIZED from the tree rather than patched as text.
+ * That is the whole point of the canonical tree: correctness is judged by the two D9
+ * oracles (the namespace-aware fingerprint and the save/reopen semantic digest), not by
+ * byte equality, so a different-but-equivalent spelling is not a defect.
+ *
+ * `writeZip` re-validates every part name, so a name that became unsafe between load and
+ * save cannot be smuggled into the archive.
+ */
+declare function writeOoxmlPackage(pkg: OoxmlPackage): Uint8Array;
+/** Replace one part's tree, returning a new package. Pure, like the tree edits themselves. */
+declare function withPart(pkg: OoxmlPackage, part: OoxmlPart): OoxmlPackage;
+
+/**
+ * Whether a drawing sits in the text flow or is positioned against a frame.
+ *
+ * The distinction that decides everything downstream: an inline drawing occupies a character
+ * position, while an anchored one has offsets relative to a page, margin or column.
+ */
+type DrawingKind = 'inline' | 'anchored';
+/** Nine Word wrap menu targets (inline plus eight floating modes). @public */
+type ImageWrapTarget = 'inline' | 'square' | 'squareLeft' | 'squareRight' | 'tight' | 'through' | 'topAndBottom' | 'behind' | 'inFront';
+/** Every text-wrap mode a drawing may be set to, including `inline`. */
+declare const IMAGE_WRAP_TARGETS: readonly ImageWrapTarget[];
+type DrawingWrapElement = 'none' | 'square' | 'tight' | 'through' | 'topAndBottom';
+type DrawingHorizontalReferenceFrame = 'character' | 'column' | 'insideMargin' | 'leftMargin' | 'margin' | 'outsideMargin' | 'page' | 'rightMargin';
+type DrawingVerticalReferenceFrame = 'bottomMargin' | 'insideMargin' | 'line' | 'margin' | 'outsideMargin' | 'page' | 'paragraph' | 'topMargin';
+/** `a:srcRect` — how much of each edge of the source image is cropped away, as fractions. */
+interface SourceCrop {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+interface DrawingTransform {
+    readonly rotationDegrees: number;
+    readonly flipHorizontal: boolean;
+    readonly flipVertical: boolean;
+    /** Source `a:off` in EMU; defaults to origin when absent. */
+    readonly offsetEmu: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    /** Source `a:ext` in EMU; zero falls back to `wp:extent` at geometry time. */
+    readonly extentEmu: Readonly<{
+        cx: number;
+        cy: number;
+    }>;
+}
+/**
+ * What a drawing refuses: selection, movement, resizing, aspect change.
+ *
+ * Read and honoured rather than advisory — chrome that offered a handle the store will refuse
+ * would promise an edit that cannot happen.
+ */
+interface DrawingLocks {
+    readonly select: boolean;
+    readonly move: boolean;
+    readonly resize: boolean;
+    readonly changeAspect: boolean;
+}
+interface DrawingLocksInput {
+    readonly select?: boolean;
+    readonly move?: boolean;
+    readonly resize?: boolean;
+    readonly changeAspect?: boolean;
+}
+/**
+ * An anchored drawing's position: offsets, and the frames they are relative to.
+ *
+ * The relative-to bases matter as much as the offsets. Writing an offset without preserving its
+ * base re-anchors the drawing against a different reference and moves it somewhere nobody asked.
+ */
+interface DrawingPositionInput {
+    /**
+     * `'simple'` when `@simplePos="1"`: `horizontalEmu` / `verticalEmu` are authoritative
+     * `wp:simplePos` x/y. `'frame'` (default) uses positionH/V relative frames.
+     */
+    readonly mode?: 'frame' | 'simple';
+    readonly horizontalEmu?: number;
+    readonly verticalEmu?: number;
+    readonly relativeToH?: DrawingHorizontalReferenceFrame;
+    readonly relativeToV?: DrawingVerticalReferenceFrame;
+}
+interface DrawingProjection {
+    readonly drawingNodeId: string;
+    readonly ownerPartName: string;
+    readonly kind: DrawingKind;
     readonly relationshipId: string | null;
     readonly docPrId: number | null;
     readonly name: string;
@@ -1799,103 +1887,15 @@ declare function projectDrawing(drawing: OoxmlDrawingNode, context: Readonly<{
     resolveStyleMatrixReference?: ShapeStyleMatrixResolver;
 }>): DrawingProjection | null;
 
-/** Caps applied while loading a package: zip, XML, part count and relationship count. */
-interface OoxmlPackageLimits {
-    readonly zip?: ZipLimits;
-    readonly xml?: XmlLimits;
-    /** Cap on parts converted into canonical trees (N/N+1 gate, not a soft target). */
-    readonly maxXmlParts?: number;
-    /** Cap on relationship records across every rels part. */
-    readonly maxRelationships?: number;
-}
-/** The limits in force when a host configures none. Conservative and finite. */
-declare const DEFAULT_OOXML_PACKAGE_LIMITS: Required<Pick<OoxmlPackageLimits, 'maxXmlParts' | 'maxRelationships'>>;
-/**
- * An external relationship target. Retained verbatim as authored evidence, with the
- * sink-safety verdict alongside it. Never resolved against the package, never fetched.
- */
-interface OoxmlExternalTarget {
-    readonly ownerPart: string;
-    readonly id: string;
-    readonly type: string;
-    readonly rawTarget: string;
-    /** False when the target is not a safe sink (javascript:, file:, ...). Still not fetched. */
-    readonly sinkSafe: boolean;
+/** The `w15` namespace: `commentsExtended.xml` — thread parent and resolved state. */
+declare const W15_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2012/wordml";
+/** A position in one story: a paragraph node id plus a UTF-16 offset inside it. */
+interface CommentPosition {
+    readonly paragraphId: string;
+    readonly offset: number;
 }
 /**
- * A loaded package: every XML part as a canonical tree, plus the non-XML parts kept verbatim.
- *
- * The preservation model in one value. Modelled parts re-emit normalized; everything else is
- * byte-identical, which is why an unrecognized part never costs a document anything.
- */
-interface OoxmlPackage {
-    /** Canonical trees, keyed by canonical part name. Non-XML parts are absent by design. */
-    readonly parts: ReadonlyMap<string, OoxmlPart>;
-    /** Raw bytes of every entry, including the non-XML parts that have no tree. */
-    readonly partBytes: ReadonlyMap<string, Uint8Array>;
-    /** Internal relationships by owner part, in authored order. */
-    readonly relationships: ReadonlyMap<string, readonly RelationshipRecord[]>;
-    readonly externalTargets: readonly OoxmlExternalTarget[];
-    readonly contentTypes: ContentTypeIndex;
-    /** Canonical name of the part the root `officeDocument` relationship points at. */
-    readonly mainDocumentPart: string;
-}
-/** Why a package could not be loaded. Every code describes the FILE, not the caller. */
-type OoxmlPackageRejection = ZipRejection | OoxmlReadRejection | 'no-content-types' | 'bad-content-types' | 'no-main-document' | 'bad-relationship-target' | 'duplicate-relationship-id' | 'too-many-relationships' | 'too-many-xml-parts';
-/** A loaded package, or a typed refusal. Never throws. */
-type OoxmlPackageResult = {
-    readonly ok: true;
-    readonly package: OoxmlPackage;
-} | {
-    readonly ok: false;
-    readonly reason: OoxmlPackageRejection;
-    readonly detail?: string;
-    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
-};
-/**
- * Load DOCX bytes into canonical typed/generic OOXML trees, bounded at every step.
- *
- * THE trust boundary for a document. Composes the hardened primitives — zip limits and OPC name
- * normalization, content-type indexing, relationship validation, entity-free XML — into one
- * loader, and returns a typed rejection rather than throwing from inside a decoder.
- *
- * Fails closed on every limit, malformed name, unresolvable internal target, duplicate
- * relationship id, and XML rejection. An external relationship never causes a failure and
- * never causes a fetch: it is recorded with its sink-safety verdict for a later, explicitly
- * user-gated lane. A content-type record with an invalid MIME type is treated as absent,
- * unless it decides the type of the main document part, a relationships part, or a
- * non-payload part that the package root or the main document relates to.
- */
-declare function readOoxmlPackage(bytes: Uint8Array, limits?: OoxmlPackageLimits): OoxmlPackageResult;
-/**
- * Serialize a canonical package back to DOCX bytes.
- *
- * Starts from the ORIGINAL entry bytes and overwrites only the parts held as trees. A part
- * the loader did not model — media, fonts, an XML part outside the modeled set — passes
- * through untouched, so round-tripping a document cannot lose a part the engine never
- * claimed to understand.
- *
- * The modeled parts are re-emitted NORMALIZED from the tree rather than patched as text.
- * That is the whole point of the canonical tree: correctness is judged by the two D9
- * oracles (the namespace-aware fingerprint and the save/reopen semantic digest), not by
- * byte equality, so a different-but-equivalent spelling is not a defect.
- *
- * `writeZip` re-validates every part name, so a name that became unsafe between load and
- * save cannot be smuggled into the archive.
- */
-declare function writeOoxmlPackage(pkg: OoxmlPackage): Uint8Array;
-/** Replace one part's tree, returning a new package. Pure, like the tree edits themselves. */
-declare function withPart(pkg: OoxmlPackage, part: OoxmlPart): OoxmlPackage;
-
-/** The `w15` namespace: `commentsExtended.xml` — thread parent and resolved state. */
-declare const W15_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2012/wordml";
-/** A position in one story: a paragraph node id plus a UTF-16 offset inside it. */
-interface CommentPosition {
-    readonly paragraphId: string;
-    readonly offset: number;
-}
-/**
- * Where a comment is anchored, as a range.
+ * Where a comment is anchored, as a range.
  *
  * `orphaned` records that the file did not give this comment a usable range — a reference with
  * no range markers, or a start with no end. The comment is still listed, marked orphaned,
@@ -1950,19 +1950,246 @@ declare function commentsOfPart(part: OoxmlPart): CommentRecord[];
 /**
  * Thread state by `w14:paraId`, from `commentsExtended.xml`.
  *
- * The part being PRESENT is not evidence of threading. `issue-68-large-comments-suggestions.docx`
- * ships it with 212 entries carrying `@w15:done` and not one `@w15:paraIdParent`, so it records
- * resolved state for a flat list. Absent parent means top-level, and that is a fact about the
- * file rather than a default this code chose.
+ * The part being PRESENT is not evidence of threading. `issue-68-large-comments-suggestions.docx`
+ * ships it with 212 entries carrying `@w15:done` and not one `@w15:paraIdParent`, so it records
+ * resolved state for a flat list. Absent parent means top-level, and that is a fact about the
+ * file rather than a default this code chose.
+ */
+declare function threadStateOfPart(part: OoxmlPart): Map<string, CommentThreadState>;
+/**
+ * Whether the package holds any `w:comment` record — the cheap gate before a reap.
+ *
+ * Overflow cannot prove the package is comment-free, so it returns true and the reap still
+ * runs rather than skipping cleanup.
+ */
+declare function hasAnyComment(pkg: OoxmlPackage): boolean;
+
+/** How deep controls may nest before a walk stops descending. Shared by every lane. */
+declare const MAX_CONTENT_CONTROL_NESTING = 32;
+/** Cap on controls one walk reports, so a hostile file cannot make a read unbounded. */
+declare const MAX_CONTENT_CONTROLS_PER_PART = 10000;
+/** `CT_SdtPr/w:id` is `ST_DecimalNumber`; Word treats it as a signed 32-bit integer. */
+declare const CONTENT_CONTROL_ID_MAX = 2147483647;
+/** `ST_Lock` (§17.5.2.24). An absent `w:lock` is `unlocked`. */
+/**
+ * `w:lock` — what a control refuses.
+ *
+ * `sdtLocked` protects the wrapper, `contentLocked` the text inside it, and `sdtContentLocked`
+ * both. A control inside a locked one is locked in effect regardless of its own value.
+ */
+type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
+/**
+ * What kind of control this is.
+ *
+ * `checkbox` is the Microsoft `w14:checkbox` extension rather than an ECMA-376 type
+ * element, and the two are not mutually exclusive with "declares no type": four controls
+ * in the comprehensive fixture declare the extension and no `w:`-prefixed type, so a scan
+ * that read only the ECMA-376 choice reported them untyped. `untyped` means the control
+ * declares neither — a rich-text container, which is what Word treats it as.
+ */
+/** Which kind of control a `w:sdt` is, and therefore what a written value must look like. */
+type ContentControlKind = 'richText' | 'plainText' | 'checkbox' | 'dropDownList' | 'comboBox' | 'date' | 'picture' | 'docPartObj' | 'docPartList' | 'group' | 'citation' | 'bibliography' | 'equation' | 'untyped';
+/** One declared option of a dropdown or combo box: its display text and its stored value. */
+interface ContentControlListItem {
+    readonly displayText: string;
+    readonly value: string;
+}
+/** A date picker's authored format and locale, for rendering and for parsing what it stores. */
+interface ContentControlDateFormat {
+    readonly fullDate?: string;
+    readonly dateFormat?: string;
+    readonly lid?: string;
+    readonly storeMappedDataAs?: string;
+    readonly calendar?: string;
+}
+/** One of a checkbox's two glyphs: the font and code point it is drawn with. */
+interface ContentControlCheckboxState {
+    /** The `w14:val` hex code point of the glyph, exactly as the control declares it. */
+    readonly value: string;
+    readonly font?: string;
+}
+/**
+ * A checkbox's state and the two glyphs it chooses between.
+ *
+ * Both glyphs matter on a write: setting the value has to update `w14:checked` AND the run's
+ * character, or the document's glyph and its recorded state disagree.
+ */
+interface ContentControlCheckbox {
+    readonly checked: boolean;
+    readonly checkedState?: ContentControlCheckboxState;
+    readonly uncheckedState?: ContentControlCheckboxState;
+}
+/** `CT_DataBinding` — preserved metadata. Never resolved, never fetched. */
+/** `w:dataBinding` — the custom-XML part and XPath a control's value is bound to. */
+interface ContentControlDataBinding {
+    readonly xpath?: string;
+    readonly storeItemID?: string;
+    readonly prefixMappings?: string;
+}
+/**
+ * A control's whole `w:sdtPr`, projected into one typed shape.
+ *
+ * What every other lane reads instead of walking `localName` strings — which also means a Word
+ * re-save that demotes the properties node to generic does not break the projection.
+ */
+interface ContentControlProperties {
+    readonly type: ContentControlKind;
+    readonly alias?: string;
+    readonly tag?: string;
+    /** `@w:val` of `w:id` when the file declares a parseable one. Never fabricated. */
+    readonly id?: number;
+    readonly lock: ContentControlLock;
+    /** The glossary entry named by `w:placeholder/w:docPart`. Preserved, never loaded. */
+    readonly placeholderDocPart?: string;
+    readonly temporary: boolean;
+    readonly showingPlaceholder: boolean;
+    readonly dataBinding?: ContentControlDataBinding;
+    readonly label?: string;
+    readonly tabIndex?: number;
+    /** Items a dropdown or combo box offers. Empty for every other type. */
+    readonly listItems: readonly ContentControlListItem[];
+    readonly lastValue?: string;
+    readonly date?: ContentControlDateFormat;
+    readonly multiLine?: boolean;
+    readonly checkbox?: ContentControlCheckbox;
+}
+/** Whether a node is a `w:sdt` wrapper. */
+declare function isContentControlNode(node: OoxmlNode): node is OoxmlContentControlNode;
+/** Whether a node is a `w:sdtContent` — the container holding a control's actual content. */
+declare function isContentControlContentNode(node: OoxmlNode): node is OoxmlContentControlContentNode;
+/**
+ * A `w:sdt` wrapper, TYPED or DEMOTED.
+ *
+ * Flattening predates typing and must not stop at a control the reader refused to type: a
+ * demoted wrapper still renders its content in place in Word, so a walk that only saw the
+ * typed kind would drop every paragraph inside a malformed control out of the story.
+ */
+declare function isContentControlWrapper(node: OoxmlNode): boolean;
+/**
+ * The children of a wrapper's `w:sdtContent`, typed or demoted, in order.
+ *
+ * The one place that knows a control's content is reached through an intermediate element,
+ * so the four flattening walks (story blocks, layout, header/footer references, list
+ * resolution) ask the same question rather than each re-deriving it.
+ */
+declare function contentControlContentChildren(wrapper: OoxmlNode): readonly OoxmlNode[];
+/**
+ * A container's children with every content-control wrapper flattened away, bounded in depth.
+ *
+ * ONE unwrap rule, for the places where a control sits between a container and the children that
+ * container is defined in terms of. `CT_SdtRow` puts it between `w:tbl` and `w:tr`, `CT_SdtCell`
+ * between `w:tr` and `w:tc`, and a walk that filtered on the child's kind dropped the row or cell
+ * entirely: not measured, not painted, not addressable. Flattening at the point of the filter
+ * means a controlled row is the same row to the grid pass, the pagination pass and the story walk.
+ *
+ * Returns the SAME array identity when there is nothing to unwrap, so the tables that carry no
+ * controls — nearly all of them — allocate nothing and the incremental layout cache still sees
+ * its own inputs.
+ */
+declare function flattenContentControls(children: readonly OoxmlNode[], maxDepth?: number): readonly OoxmlNode[];
+/** A control's `w:sdtPr`, or null. Matches structurally, so a Word-demoted node still resolves. */
+declare function contentControlPropertiesNodeOf(control: OoxmlNode): OoxmlContentControlPropertiesNode | undefined;
+/** A control's `w:sdtEndPr` — the run properties applied to its closing marker. */
+declare function contentControlEndPropertiesNodeOf(control: OoxmlNode): OoxmlContentControlEndPropertiesNode | undefined;
+/** A control's `w:sdtContent`, or null when the wrapper has none. */
+declare function contentControlContentNodeOf(control: OoxmlNode): OoxmlContentControlContentNode | undefined;
+/** A signed 32-bit `ST_DecimalNumber`, or undefined when the file wrote something else. */
+declare function parseContentControlId(raw: string | undefined): number | undefined;
+/**
+ * Read a control's properties.
+ *
+ * Total: a control with no `w:sdtPr` at all answers the same shape with the defaults an
+ * absent property means, so no caller has to branch on the container's existence.
+ */
+declare function contentControlPropertiesOf(control: OoxmlNode): ContentControlProperties;
+/** Where a control sits, read off what its content holds. */
+type ContentControlLevel = 'block' | 'inline' | 'row' | 'cell' | 'empty';
+/**
+ * How deeply a control is nested inside other controls.
+ *
+ * Bounded by {@link MAX_CONTENT_CONTROL_NESTING}: nesting depth comes from a file and is a
+ * recursion bound.
+ */
+declare function contentControlLevelOf(control: OoxmlNode): ContentControlLevel;
+/** One control, plus how deeply it is nested and the controls that enclose it. */
+interface ContentControlEntry {
+    readonly node: OoxmlContentControlNode;
+    /** 0 for a top-level control; the nesting depth otherwise. */
+    readonly depth: number;
+    /** Enclosing controls, outermost first. Empty at depth 0. */
+    readonly ancestors: readonly OoxmlContentControlNode[];
+}
+/**
+ * Every control under a node, in document order, bounded in depth and in count.
+ *
+ * ONE walk, shared. The nesting bound is the same one layout flattens with, so a control
+ * a lane can address is a control every lane can address — and a file that nests past it
+ * keeps its content in the tree (the serializer never stops) while no walk recurses
+ * further.
+ */
+declare function contentControlsIn(root: OoxmlNode, options?: {
+    readonly maxDepth?: number;
+    readonly limit?: number;
+}): readonly ContentControlEntry[];
+/** Find one control by canonical node id, with the same bounded walk. */
+declare function findContentControl(root: OoxmlNode, nodeId: string): ContentControlEntry | null;
+/**
+ * The plain text a control's content holds, in reading order.
+ *
+ * `w:delText` is excluded: struck text is not the control's value, and a dropdown whose
+ * old item is still present as a tracked deletion would otherwise report both.
+ *
+ * A manual line break is left out unless `lineBreak` names the text to report it as.
+ * With that option, column breaks report U+000E so callers cannot silently discard them.
+ */
+declare function contentControlTextOf(control: OoxmlNode, lineBreak?: string): string;
+/**
+ * Resolve the lock a position inherits from the controls enclosing it.
+ *
+ * CONSERVATIVE, because a template that says a field cannot be edited and sits inside a
+ * section that says it cannot be removed means both. Each half of `ST_Lock` is taken
+ * independently and the strongest wins, so an unlocked control inside a `contentLocked`
+ * one is still content-locked — a nested control cannot grant a permission its parent
+ * withheld, which is the only reading under which a lock is a lock.
+ */
+declare function resolveContentControlLock(chain: readonly ContentControlLock[]): ContentControlLock;
+/** Whether a resolved lock forbids editing the content it covers. */
+declare function lockForbidsEdit(lock: ContentControlLock): boolean;
+/** Whether a resolved lock forbids removing the control itself. */
+declare function lockForbidsRemoval(lock: ContentControlLock): boolean;
+/**
+ * `CT_SdtPr`'s declared child order (§17.5.2.38), followed by the type choice.
+ *
+ * Serialization re-emits children in tree order, so the ONLY way a write keeps the
+ * sequence valid is to place the child it authors at its schema position — which is what
+ * {@link orderedContentControlProperties} does.
+ */
+declare const CONTENT_CONTROL_PROPERTY_ORDER: readonly string[];
+/**
+ * Rebuild a `w:sdtPr`'s children in schema order.
+ *
+ * Modelled children sort to their declared position and the type element follows them,
+ * as the sequence requires. Everything else — a `w15:repeatingSection`, a vendor
+ * extension, the `w14:checkbox` that is not part of the ECMA-376 choice — keeps the order
+ * it was authored in and follows the modelled block, so a write that touches one property
+ * neither drops nor reorders anything it does not name.
  */
-declare function threadStateOfPart(part: OoxmlPart): Map<string, CommentThreadState>;
+declare function orderedContentControlProperties(children: readonly OoxmlNode[]): readonly OoxmlNode[];
 /**
- * Whether the package holds any `w:comment` record — the cheap gate before a reap.
+ * The next `w:id` to write.
  *
- * Overflow cannot prove the package is comment-free, so it returns true and the reap still
- * runs rather than skipping cleanup.
+ * Solo: one past the document's own maximum. Never a clock, a timestamp, a random source
+ * or a hash: those collide with ids already in the file and produce values Word rejects.
+ * Null when the document already reaches the signed 32-bit bound, so the caller refuses
+ * rather than wrapping into a negative id. Hostile or out-of-range existing values are
+ * ignored for seeding rather than counted past.
+ *
+ * When a collaboration actor is bound (explicit argument or the open store transaction),
+ * the next id is the next unused value in that actor's stripe. Two peers inserting a
+ * generic content control — including a custom node authored as `w:sdt` — from the same
+ * snapshot then cannot share a `w:id`.
  */
-declare function hasAnyComment(pkg: OoxmlPackage): boolean;
+declare function allocateContentControlId(root: OoxmlNode, actorId?: string): number | null;
 
 /** A position in the model offset space of one story. */
 interface ReviewPosition {
@@ -2259,232 +2486,14 @@ declare function activeReviewItem(items: readonly ReviewItem[], position: Review
  */
 declare function reviewThreadRootOf(items: readonly ReviewItem[], comment: ReviewCommentItem): ReviewItem;
 
-/** How deep controls may nest before a walk stops descending. Shared by every lane. */
-declare const MAX_CONTENT_CONTROL_NESTING = 32;
-/** Cap on controls one walk reports, so a hostile file cannot make a read unbounded. */
-declare const MAX_CONTENT_CONTROLS_PER_PART = 10000;
-/** `CT_SdtPr/w:id` is `ST_DecimalNumber`; Word treats it as a signed 32-bit integer. */
-declare const CONTENT_CONTROL_ID_MAX = 2147483647;
-/** `ST_Lock` (§17.5.2.24). An absent `w:lock` is `unlocked`. */
-/**
- * `w:lock` — what a control refuses.
- *
- * `sdtLocked` protects the wrapper, `contentLocked` the text inside it, and `sdtContentLocked`
- * both. A control inside a locked one is locked in effect regardless of its own value.
- */
-type ContentControlLock = 'unlocked' | 'sdtLocked' | 'contentLocked' | 'sdtContentLocked';
-/**
- * What kind of control this is.
- *
- * `checkbox` is the Microsoft `w14:checkbox` extension rather than an ECMA-376 type
- * element, and the two are not mutually exclusive with "declares no type": four controls
- * in the comprehensive fixture declare the extension and no `w:`-prefixed type, so a scan
- * that read only the ECMA-376 choice reported them untyped. `untyped` means the control
- * declares neither — a rich-text container, which is what Word treats it as.
- */
-/** Which kind of control a `w:sdt` is, and therefore what a written value must look like. */
-type ContentControlKind = 'richText' | 'plainText' | 'checkbox' | 'dropDownList' | 'comboBox' | 'date' | 'picture' | 'docPartObj' | 'docPartList' | 'group' | 'citation' | 'bibliography' | 'equation' | 'untyped';
-/** One declared option of a dropdown or combo box: its display text and its stored value. */
-interface ContentControlListItem {
-    readonly displayText: string;
-    readonly value: string;
-}
-/** A date picker's authored format and locale, for rendering and for parsing what it stores. */
-interface ContentControlDateFormat {
-    readonly fullDate?: string;
-    readonly dateFormat?: string;
-    readonly lid?: string;
-    readonly storeMappedDataAs?: string;
-    readonly calendar?: string;
-}
-/** One of a checkbox's two glyphs: the font and code point it is drawn with. */
-interface ContentControlCheckboxState {
-    /** The `w14:val` hex code point of the glyph, exactly as the control declares it. */
-    readonly value: string;
-    readonly font?: string;
-}
-/**
- * A checkbox's state and the two glyphs it chooses between.
- *
- * Both glyphs matter on a write: setting the value has to update `w14:checked` AND the run's
- * character, or the document's glyph and its recorded state disagree.
- */
-interface ContentControlCheckbox {
-    readonly checked: boolean;
-    readonly checkedState?: ContentControlCheckboxState;
-    readonly uncheckedState?: ContentControlCheckboxState;
-}
-/** `CT_DataBinding` — preserved metadata. Never resolved, never fetched. */
-/** `w:dataBinding` — the custom-XML part and XPath a control's value is bound to. */
-interface ContentControlDataBinding {
-    readonly xpath?: string;
-    readonly storeItemID?: string;
-    readonly prefixMappings?: string;
-}
-/**
- * A control's whole `w:sdtPr`, projected into one typed shape.
- *
- * What every other lane reads instead of walking `localName` strings — which also means a Word
- * re-save that demotes the properties node to generic does not break the projection.
- */
-interface ContentControlProperties {
-    readonly type: ContentControlKind;
-    readonly alias?: string;
-    readonly tag?: string;
-    /** `@w:val` of `w:id` when the file declares a parseable one. Never fabricated. */
-    readonly id?: number;
-    readonly lock: ContentControlLock;
-    /** The glossary entry named by `w:placeholder/w:docPart`. Preserved, never loaded. */
-    readonly placeholderDocPart?: string;
-    readonly temporary: boolean;
-    readonly showingPlaceholder: boolean;
-    readonly dataBinding?: ContentControlDataBinding;
-    readonly label?: string;
-    readonly tabIndex?: number;
-    /** Items a dropdown or combo box offers. Empty for every other type. */
-    readonly listItems: readonly ContentControlListItem[];
-    readonly lastValue?: string;
-    readonly date?: ContentControlDateFormat;
-    readonly multiLine?: boolean;
-    readonly checkbox?: ContentControlCheckbox;
-}
-/** Whether a node is a `w:sdt` wrapper. */
-declare function isContentControlNode(node: OoxmlNode): node is OoxmlContentControlNode;
-/** Whether a node is a `w:sdtContent` — the container holding a control's actual content. */
-declare function isContentControlContentNode(node: OoxmlNode): node is OoxmlContentControlContentNode;
-/**
- * A `w:sdt` wrapper, TYPED or DEMOTED.
- *
- * Flattening predates typing and must not stop at a control the reader refused to type: a
- * demoted wrapper still renders its content in place in Word, so a walk that only saw the
- * typed kind would drop every paragraph inside a malformed control out of the story.
- */
-declare function isContentControlWrapper(node: OoxmlNode): boolean;
 /**
- * The children of a wrapper's `w:sdtContent`, typed or demoted, in order.
- *
- * The one place that knows a control's content is reached through an intermediate element,
- * so the four flattening walks (story blocks, layout, header/footer references, list
- * resolution) ask the same question rather than each re-deriving it.
- */
-declare function contentControlContentChildren(wrapper: OoxmlNode): readonly OoxmlNode[];
-/**
- * A container's children with every content-control wrapper flattened away, bounded in depth.
- *
- * ONE unwrap rule, for the places where a control sits between a container and the children that
- * container is defined in terms of. `CT_SdtRow` puts it between `w:tbl` and `w:tr`, `CT_SdtCell`
- * between `w:tr` and `w:tc`, and a walk that filtered on the child's kind dropped the row or cell
- * entirely: not measured, not painted, not addressable. Flattening at the point of the filter
- * means a controlled row is the same row to the grid pass, the pagination pass and the story walk.
- *
- * Returns the SAME array identity when there is nothing to unwrap, so the tables that carry no
- * controls — nearly all of them — allocate nothing and the incremental layout cache still sees
- * its own inputs.
- */
-declare function flattenContentControls(children: readonly OoxmlNode[], maxDepth?: number): readonly OoxmlNode[];
-/** A control's `w:sdtPr`, or null. Matches structurally, so a Word-demoted node still resolves. */
-declare function contentControlPropertiesNodeOf(control: OoxmlNode): OoxmlContentControlPropertiesNode | undefined;
-/** A control's `w:sdtEndPr` — the run properties applied to its closing marker. */
-declare function contentControlEndPropertiesNodeOf(control: OoxmlNode): OoxmlContentControlEndPropertiesNode | undefined;
-/** A control's `w:sdtContent`, or null when the wrapper has none. */
-declare function contentControlContentNodeOf(control: OoxmlNode): OoxmlContentControlContentNode | undefined;
-/** A signed 32-bit `ST_DecimalNumber`, or undefined when the file wrote something else. */
-declare function parseContentControlId(raw: string | undefined): number | undefined;
-/**
- * Read a control's properties.
- *
- * Total: a control with no `w:sdtPr` at all answers the same shape with the defaults an
- * absent property means, so no caller has to branch on the container's existence.
- */
-declare function contentControlPropertiesOf(control: OoxmlNode): ContentControlProperties;
-/** Where a control sits, read off what its content holds. */
-type ContentControlLevel = 'block' | 'inline' | 'row' | 'cell' | 'empty';
-/**
- * How deeply a control is nested inside other controls.
- *
- * Bounded by {@link MAX_CONTENT_CONTROL_NESTING}: nesting depth comes from a file and is a
- * recursion bound.
- */
-declare function contentControlLevelOf(control: OoxmlNode): ContentControlLevel;
-/** One control, plus how deeply it is nested and the controls that enclose it. */
-interface ContentControlEntry {
-    readonly node: OoxmlContentControlNode;
-    /** 0 for a top-level control; the nesting depth otherwise. */
-    readonly depth: number;
-    /** Enclosing controls, outermost first. Empty at depth 0. */
-    readonly ancestors: readonly OoxmlContentControlNode[];
-}
-/**
- * Every control under a node, in document order, bounded in depth and in count.
- *
- * ONE walk, shared. The nesting bound is the same one layout flattens with, so a control
- * a lane can address is a control every lane can address — and a file that nests past it
- * keeps its content in the tree (the serializer never stops) while no walk recurses
- * further.
- */
-declare function contentControlsIn(root: OoxmlNode, options?: {
-    readonly maxDepth?: number;
-    readonly limit?: number;
-}): readonly ContentControlEntry[];
-/** Find one control by canonical node id, with the same bounded walk. */
-declare function findContentControl(root: OoxmlNode, nodeId: string): ContentControlEntry | null;
-/**
- * The plain text a control's content holds, in reading order.
- *
- * `w:delText` is excluded: struck text is not the control's value, and a dropdown whose
- * old item is still present as a tracked deletion would otherwise report both.
- *
- * A manual line break is left out unless `lineBreak` names the text to report it as.
- * With that option, column breaks report U+000E so callers cannot silently discard them.
- */
-declare function contentControlTextOf(control: OoxmlNode, lineBreak?: string): string;
-/**
- * Resolve the lock a position inherits from the controls enclosing it.
- *
- * CONSERVATIVE, because a template that says a field cannot be edited and sits inside a
- * section that says it cannot be removed means both. Each half of `ST_Lock` is taken
- * independently and the strongest wins, so an unlocked control inside a `contentLocked`
- * one is still content-locked — a nested control cannot grant a permission its parent
- * withheld, which is the only reading under which a lock is a lock.
- */
-declare function resolveContentControlLock(chain: readonly ContentControlLock[]): ContentControlLock;
-/** Whether a resolved lock forbids editing the content it covers. */
-declare function lockForbidsEdit(lock: ContentControlLock): boolean;
-/** Whether a resolved lock forbids removing the control itself. */
-declare function lockForbidsRemoval(lock: ContentControlLock): boolean;
-/**
- * `CT_SdtPr`'s declared child order (§17.5.2.38), followed by the type choice.
- *
- * Serialization re-emits children in tree order, so the ONLY way a write keeps the
- * sequence valid is to place the child it authors at its schema position — which is what
- * {@link orderedContentControlProperties} does.
- */
-declare const CONTENT_CONTROL_PROPERTY_ORDER: readonly string[];
-/**
- * Rebuild a `w:sdtPr`'s children in schema order.
- *
- * Modelled children sort to their declared position and the type element follows them,
- * as the sequence requires. Everything else — a `w15:repeatingSection`, a vendor
- * extension, the `w14:checkbox` that is not part of the ECMA-376 choice — keeps the order
- * it was authored in and follows the modelled block, so a write that touches one property
- * neither drops nor reorders anything it does not name.
- */
-declare function orderedContentControlProperties(children: readonly OoxmlNode[]): readonly OoxmlNode[];
-/**
- * The next `w:id` to write.
- *
- * Solo: one past the document's own maximum. Never a clock, a timestamp, a random source
- * or a hash: those collide with ids already in the file and produce values Word rejects.
- * Null when the document already reaches the signed 32-bit bound, so the caller refuses
- * rather than wrapping into a negative id. Hostile or out-of-range existing values are
- * ignored for seeding rather than counted past.
+ * Why a revision site cannot be resolved: no `w:id` or author, a content marker where content
+ * cannot be, a wrapper whose content is itself marked, a structural revision outside tables and
+ * numbering, or a move whose ranges do not pair up.
  *
- * When a collaboration actor is bound (explicit argument or the open store transaction),
- * the next id is the next unused value in that actor's stripe. Two peers inserting a
- * generic content control — including a custom node authored as `w:sdt` — from the same
- * snapshot then cannot share a `w:id`.
+ * @public
  */
-declare function allocateContentControlId(root: OoxmlNode, actorId?: string): number | null;
+type RevisionSiteRefusal = 'unaddressed' | 'misplaced-marker' | 'nested-marker' | 'unsupported-structure' | 'unsupported-move';
 
 /** The value a control accepts, by what kind of control it is. */
 type ContentControlValueInput = {
@@ -2519,9 +2528,19 @@ interface RevisionBatchEntry {
     readonly author: string;
     readonly partName: string;
     readonly revisionKind: ReviewRevisionItem['revisionKind'];
+    /** For a formatting change, its OOXML property-change element, as the review item has it. */
+    readonly formattingKind?: string;
 }
 /** Why a requested decision remains pending. @public */
 type RevisionBatchSkipReason = 'unsupported-revision' | 'incomplete-group' | 'retained-structure' | 'unknown-revision';
+/**
+ * Why an `unsupported-revision` skip happened: a refused site, a formatting change whose earlier
+ * properties were not recorded so it cannot be rejected, a read-only review item, or a change
+ * with no sites in the part.
+ *
+ * @public
+ */
+type RevisionBatchSkipDetail = RevisionSiteRefusal | 'unrecorded-properties' | 'read-only' | 'no-sites';
 /** Outcome of one selected-set decision. Counts refer to review decisions, not XML markers. @public */
 interface RevisionBatchResult {
     readonly resolved: readonly RevisionBatchEntry[];
@@ -2529,6 +2548,8 @@ interface RevisionBatchResult {
         readonly key: string;
         readonly reason: RevisionBatchSkipReason;
         readonly revision?: RevisionBatchEntry;
+        /** For `unsupported-revision`, which engine condition refused it. */
+        readonly detail?: RevisionBatchSkipDetail;
     }[];
     /** All pending decisions in the addressed scope, including excluded and unsupported changes. */
     readonly remaining: number;
@@ -4265,5 +4286,5 @@ type TreeOpResult = {
     readonly detail?: string;
 };
 
-export { CONTENT_CONTROL_ID_MAX as a$, IMAGE_WRAP_TARGETS as aH, TEXT_FORM_FORMATS as aI, ACCEPTED_PARAGRAPH_PROPERTIES as aZ, ACCEPTED_RUN_PROPERTIES as a_, CONTENT_CONTROL_PROPERTY_ORDER as b0, DEFAULT_OOXML_PACKAGE_LIMITS as bh, DEFAULT_ZIP_LIMITS as bi, HYPERLINK_RELATIONSHIP_TYPE as bl, IMAGE_RELATIONSHIP_TYPE as bo, MAX_CONTENT_CONTROLS_PER_PART as bu, MAX_CONTENT_CONTROL_NESTING as bv, OFFICE_RELATIONSHIP_NAMESPACE_URI as by, OOXML_NODE_IDENTITY_RULES as bz, hyperlinkTargetOf as c$, allocateContentControlId as cD, asciiFold as cE, buildContentTypeIndex as cF, buildRelationshipSet as cG, childElements as cH, commentAnchorsOfStory as cI, commentsOfPart as cJ, contentControlContentChildren as cK, contentControlContentNodeOf as cL, contentControlEndPropertiesNodeOf as cM, contentControlLevelOf as cN, contentControlPropertiesNodeOf as cO, contentControlPropertiesOf as cP, contentControlTextOf as cQ, contentControlsIn as cR, detectDuplicateNames as cS, extensionKey as cT, findContentControl as cU, findElement as cV, firstReviewRange as cW, flattenContentControls as cX, hasAnyComment as cY, hyperlinkAnchorOf as cZ, hyperlinkRelationshipIdOf as c_, TABLE_BORDER_STYLES as ck, W15_NAMESPACE_URI as cs, WML_NAMESPACE_URI as ct, XMLNS_NAMESPACE_URI as cu, XML_NAMESPACE_URI as cv, isContentControlContentNode as d0, isContentControlNode as d1, isContentControlWrapper as d2, isContentRevisionKind as d3, isHyperlinkNode as d4, isRangeMarkerKind as d5, isValidMime as d6, legacyCheckboxFieldsOf as d7, lockForbidsEdit as d8, lockForbidsRemoval as d9, writeZip as dA, activeReviewItem as dC, reviewItemPositionRank as dD, reviewItemsAt as dE, reviewThreadRootOf as dF, normalizePartName as da, orderedContentControlProperties as db, parseContentControlId as dc, partNameKey as dd, planRevisionAuthorChange as de, planRevisionBatch as df, projectDrawing as dg, readOnOffChild as dh, readOoxmlPackage as di, readOoxmlPart as dj, readXml as dk, readZip as dl, resolveContentControlLock as dm, resolveContentType as dn, resolveImageRelationship as dp, resolveInternalTarget as dq, resolveRelationship as dr, reviewItemKey as ds, reviewItemRanges as dt, textContent as du, textFormFieldsOf as dv, threadStateOfPart as dw, validateExternalTarget as dx, withPart as dy, writeOoxmlPackage as dz };
-export type { OoxmlContentControlContentNode as $, ParagraphTabStop as A, Block as B, CommentRecord as C, DocxDocument as D, ExecResult as E, RevisionType as F, Section as G, HeaderFooterSet as H, InsertableContentControlType as I, SectionProperties as J, StyleDefinition as K, Theme as L, ThemeColorScheme as M, OoxmlNode as N, OoxmlPart as O, Paragraph as P, OoxmlPackage as Q, ReviewModelInput as R, StyleDefinitions as S, Table as T, OoxmlNodeId as U, OoxmlGenericElementNode as V, TreeDocOp as W, OoxmlProperty as X, OoxmlPackageRejection as Y, OoxmlElement as Z, OoxmlContentControlNode as _, ReviewItem as a, DrawingProjection as a0, OoxmlPackageLimits as a1, RevisionAuthorEntry as a2, RevisionAuthorResult as a3, RevisionAuthorSkipReason as a4, RevisionBatchEntry as a5, RevisionBatchResult as a6, RevisionBatchSkipReason as a7, TreeOpRejection as a8, AutomationTableMutation as a9, PageMargins as aA, ParagraphDisagreements as aB, Point as aC, Run as aD, TableCell as aE, TableRow as aF, TreeDocColorValue as aG, TableBorderStyle as aJ, DrawingAccessibility as aK, DrawingImageEffects as aL, DrawingTransform as aM, VectorShapeProjection as aN, OoxmlDrawingNode as aO, OoxmlInvariantResult as aP, OoxmlInvariantIssue as aQ, OoxmlFldCharNode as aR, OoxmlFldSimpleNode as aS, OoxmlInstrTextNode as aT, TreeOpResult as aU, RelationshipRecord as aV, OoxmlHardBreakNode as aW, OoxmlAttribute as aX, CommentThreadState as aY, RevisionAttributionInput as aa, OoxmlParagraphNode as ab, OoxmlNoteNode as ac, OoxmlContinuationSeparatorNode as ad, OoxmlEndnotesNode as ae, OoxmlFootnotesNode as af, OoxmlNoteRefNode as ag, OoxmlNoteReferenceNode as ah, OoxmlSeparatorNode as ai, DrawingTreeDocOp as aj, ImpactClass as ak, SourceCrop as al, DrawingKind as am, ImageWrapTarget as an, DrawingPositionInput as ao, DrawingLocks as ap, ParagraphFormatCommand as aq, Watermark as ar, Rect as as, SelectionPin as at, Unsubscribe as au, DocxDocumentJSON as av, DrawingHorizontalReferenceFrame as aw, DrawingVerticalReferenceFrame as ax, FontDefinition as ay, NumberingRef as az, ReviewRevisionItem as b, OoxmlPackageResult as b$, CommentAnchor as b1, CommentPosition as b2, CommitTextFormFieldOp as b3, ContentControlCheckbox as b4, ContentControlCheckboxState as b5, ContentControlDataBinding as b6, ContentControlDateFormat as b7, ContentControlEntry as b8, ContentControlKind as b9, OoxmlBodyNode as bA, OoxmlBookmarkEndNode as bB, OoxmlBookmarkStartNode as bC, OoxmlContentControlCalendarNode as bD, OoxmlContentControlCheckboxNode as bE, OoxmlContentControlCheckedNode as bF, OoxmlContentControlCheckedStateNode as bG, OoxmlContentControlComboBoxNode as bH, OoxmlContentControlDataBindingNode as bI, OoxmlContentControlDateFormatNode as bJ, OoxmlContentControlDateNode as bK, OoxmlContentControlDropDownListNode as bL, OoxmlContentControlEndPropertiesNode as bM, OoxmlContentControlLidNode as bN, OoxmlContentControlListItemNode as bO, OoxmlContentControlPropertiesNode as bP, OoxmlContentControlStoreMappedDataAsNode as bQ, OoxmlContentControlTextNode as bR, OoxmlContentControlUncheckedStateNode as bS, OoxmlDocumentNode as bT, OoxmlExternalTarget as bU, OoxmlGenericExtensionAttribute as bV, OoxmlHyperlinkNode as bW, OoxmlInvariantIssueCode as bX, OoxmlKnownNodeAttribute as bY, OoxmlNamespaceBinding as bZ, OoxmlNodeIdentityRules as b_, ContentControlLevel as ba, ContentControlListItem as bb, ContentControlLock as bc, ContentControlProperties as bd, ContentTypeError as be, ContentTypeIndex as bf, ContentTypeRecords as bg, DefaultRecord as bj, DeleteTextOp as bk, HyperlinkKind as bm, HyperlinkTarget as bn, ImageRelationshipResolution as bp, IndexResult as bq, InsertBuildingBlockOp as br, InsertTextOp as bs, LegacyCheckboxFieldRange as bt, NameRejection as bw, NameResult as bx, ReviewCommentItem as c, OoxmlParagraphPropertiesNode as c0, OoxmlPartMetadata as c1, OoxmlReadRejection as c2, OoxmlReadResult as c3, OoxmlRunNode as c4, OoxmlRunPropertiesNode as c5, OoxmlTabNode as c6, OoxmlTextElementNode as c7, OoxmlTextNode as c8, OoxmlWmlValAttribute as c9, ZipLimits as cA, ZipReadResult as cB, ZipRejection as cC, OoxmlXmlSpaceAttribute as ca, OverrideRecord as cb, RelationshipError as cc, RelationshipSetResult as cd, RelationshipTargetResolver as ce, ResolveResult as cf, ResolvedRelationship as cg, SetLegacyCheckboxOp as ch, SetLegacyDropdownOp as ci, SetTextFormFieldDefaultOp as cj, TabStopWrite as cl, TargetMode as cm, TextFormFieldOptions as cn, TextFormFieldRange as co, TextFormFieldType as cp, TreeDocOpKind as cq, TreeOpEffect as cr, XmlLimits as cw, XmlNode as cx, XmlRejection as cy, XmlResult as cz, ReviewCustomItem as d, VectorShapeComponent as dB, ReviewPosition as e, ReviewRange as f, ReviewRevisionKind as g, RevisionAddress as h, ContentControlType as i, DocTarget as j, RunFormatting as k, Extent as l, ContainerRef as m, ContentControlFilter as n, DocRange as o, Revision as p, DocComment as q, ColorValue as r, ContentControl as s, DocAnchor as t, DocAnchorRange as u, DocLocation as v, DocumentBody as w, ExecErrorCode as x, IndentFormatting as y, ParagraphFlags as z };
+export { IMAGE_WRAP_TARGETS as aK, TEXT_FORM_FORMATS as aL, ACCEPTED_PARAGRAPH_PROPERTIES as b2, ACCEPTED_RUN_PROPERTIES as b3, CONTENT_CONTROL_ID_MAX as b4, CONTENT_CONTROL_PROPERTY_ORDER as b5, MAX_CONTENT_CONTROL_NESTING as bA, OFFICE_RELATIONSHIP_NAMESPACE_URI as bD, OOXML_NODE_IDENTITY_RULES as bE, DEFAULT_OOXML_PACKAGE_LIMITS as bm, DEFAULT_ZIP_LIMITS as bn, HYPERLINK_RELATIONSHIP_TYPE as bq, IMAGE_RELATIONSHIP_TYPE as bt, MAX_CONTENT_CONTROLS_PER_PART as bz, hyperlinkAnchorOf as c$, allocateContentControlId as cF, asciiFold as cG, buildContentTypeIndex as cH, buildRelationshipSet as cI, childElements as cJ, commentAnchorsOfStory as cK, commentsOfPart as cL, contentControlContentChildren as cM, contentControlContentNodeOf as cN, contentControlEndPropertiesNodeOf as cO, contentControlLevelOf as cP, contentControlPropertiesNodeOf as cQ, contentControlPropertiesOf as cR, contentControlTextOf as cS, contentControlsIn as cT, detectDuplicateNames as cU, extensionKey as cV, findContentControl as cW, findElement as cX, firstReviewRange as cY, flattenContentControls as cZ, hasAnyComment as c_, TABLE_BORDER_STYLES as co, W15_NAMESPACE_URI as cu, WML_NAMESPACE_URI as cv, XMLNS_NAMESPACE_URI as cw, XML_NAMESPACE_URI as cx, hyperlinkRelationshipIdOf as d0, hyperlinkTargetOf as d1, isContentControlContentNode as d2, isContentControlNode as d3, isContentControlWrapper as d4, isContentRevisionKind as d5, isHyperlinkNode as d6, isRangeMarkerKind as d7, isValidMime as d8, legacyCheckboxFieldsOf as d9, withPart as dA, writeOoxmlPackage as dB, writeZip as dC, activeReviewItem as dE, reviewItemPositionRank as dF, reviewItemsAt as dG, reviewThreadRootOf as dH, lockForbidsEdit as da, lockForbidsRemoval as db, normalizePartName as dc, orderedContentControlProperties as dd, parseContentControlId as de, partNameKey as df, planRevisionAuthorChange as dg, planRevisionBatch as dh, projectDrawing as di, readOnOffChild as dj, readOoxmlPackage as dk, readOoxmlPart as dl, readXml as dm, readZip as dn, resolveContentControlLock as dp, resolveContentType as dq, resolveImageRelationship as dr, resolveInternalTarget as ds, resolveRelationship as dt, reviewItemKey as du, reviewItemRanges as dv, textContent as dw, textFormFieldsOf as dx, threadStateOfPart as dy, validateExternalTarget as dz };
+export type { DrawingVerticalReferenceFrame as $, ParagraphTabStop as A, Block as B, CommentRecord as C, DocxDocument as D, ExecResult as E, RevisionType as F, Section as G, HeaderFooterSet as H, InsertableContentControlType as I, SectionProperties as J, StyleDefinition as K, Theme as L, ThemeColorScheme as M, OoxmlNode as N, OoxmlPart as O, Paragraph as P, OoxmlPackage as Q, ReviewModelInput as R, StyleDefinitions as S, Table as T, OoxmlNodeId as U, OoxmlGenericElementNode as V, DocxDocumentJSON as W, DrawingHorizontalReferenceFrame as X, DrawingKind as Y, DrawingLocks as Z, DrawingPositionInput as _, ReviewItem as a, OoxmlHardBreakNode as a$, FontDefinition as a0, ImageWrapTarget as a1, NumberingRef as a2, PageMargins as a3, ParagraphDisagreements as a4, ParagraphFormatCommand as a5, Point as a6, Rect as a7, RevisionAuthorResult as a8, RevisionBatchResult as a9, OoxmlNoteNode as aA, OoxmlContinuationSeparatorNode as aB, OoxmlEndnotesNode as aC, OoxmlFootnotesNode as aD, OoxmlNoteRefNode as aE, OoxmlNoteReferenceNode as aF, OoxmlSeparatorNode as aG, ImpactClass as aH, SourceCrop as aI, TreeDocColorValue as aJ, TableBorderStyle as aM, DrawingAccessibility as aN, DrawingImageEffects as aO, DrawingTransform as aP, VectorShapeProjection as aQ, OoxmlDrawingNode as aR, TextFormFieldRange as aS, TextFormFieldOptions as aT, OoxmlInvariantResult as aU, OoxmlInvariantIssue as aV, OoxmlFldCharNode as aW, OoxmlFldSimpleNode as aX, OoxmlInstrTextNode as aY, TreeOpResult as aZ, RelationshipRecord as a_, Run as aa, SelectionPin as ab, TableCell as ac, TableRow as ad, Unsubscribe as ae, Watermark as af, TreeDocOp as ag, OoxmlProperty as ah, OoxmlPackageResult as ai, OoxmlPackageRejection as aj, OoxmlElement as ak, OoxmlContentControlNode as al, OoxmlContentControlContentNode as am, DrawingProjection as an, OoxmlPackageLimits as ao, RevisionAuthorEntry as ap, RevisionAuthorSkipReason as aq, RevisionBatchEntry as ar, RevisionBatchSkipDetail as as, RevisionBatchSkipReason as at, RevisionSiteRefusal as au, TreeOpRejection as av, AutomationTableMutation as aw, RevisionAttributionInput as ax, DrawingTreeDocOp as ay, OoxmlParagraphNode as az, ReviewRevisionItem as b, OoxmlHyperlinkNode as b$, OoxmlAttribute as b0, CommentThreadState as b1, CommentAnchor as b6, CommentPosition as b7, CommitTextFormFieldOp as b8, ContentControlCheckbox as b9, NameRejection as bB, NameResult as bC, OoxmlBodyNode as bF, OoxmlBookmarkEndNode as bG, OoxmlBookmarkStartNode as bH, OoxmlContentControlCalendarNode as bI, OoxmlContentControlCheckboxNode as bJ, OoxmlContentControlCheckedNode as bK, OoxmlContentControlCheckedStateNode as bL, OoxmlContentControlComboBoxNode as bM, OoxmlContentControlDataBindingNode as bN, OoxmlContentControlDateFormatNode as bO, OoxmlContentControlDateNode as bP, OoxmlContentControlDropDownListNode as bQ, OoxmlContentControlEndPropertiesNode as bR, OoxmlContentControlLidNode as bS, OoxmlContentControlListItemNode as bT, OoxmlContentControlPropertiesNode as bU, OoxmlContentControlStoreMappedDataAsNode as bV, OoxmlContentControlTextNode as bW, OoxmlContentControlUncheckedStateNode as bX, OoxmlDocumentNode as bY, OoxmlExternalTarget as bZ, OoxmlGenericExtensionAttribute as b_, ContentControlCheckboxState as ba, ContentControlDataBinding as bb, ContentControlDateFormat as bc, ContentControlEntry as bd, ContentControlKind as be, ContentControlLevel as bf, ContentControlListItem as bg, ContentControlLock as bh, ContentControlProperties as bi, ContentTypeError as bj, ContentTypeIndex as bk, ContentTypeRecords as bl, DefaultRecord as bo, DeleteTextOp as bp, HyperlinkKind as br, HyperlinkTarget as bs, ImageRelationshipResolution as bu, IndexResult as bv, InsertBuildingBlockOp as bw, InsertTextOp as bx, LegacyCheckboxFieldRange as by, ReviewCommentItem as c, OoxmlInvariantIssueCode as c0, OoxmlKnownNodeAttribute as c1, OoxmlNamespaceBinding as c2, OoxmlNodeIdentityRules as c3, OoxmlParagraphPropertiesNode as c4, OoxmlPartMetadata as c5, OoxmlReadRejection as c6, OoxmlReadResult as c7, OoxmlRunNode as c8, OoxmlRunPropertiesNode as c9, XmlRejection as cA, XmlResult as cB, ZipLimits as cC, ZipReadResult as cD, ZipRejection as cE, OoxmlTabNode as ca, OoxmlTextElementNode as cb, OoxmlTextNode as cc, OoxmlWmlValAttribute as cd, OoxmlXmlSpaceAttribute as ce, OverrideRecord as cf, RelationshipError as cg, RelationshipSetResult as ch, RelationshipTargetResolver as ci, ResolveResult as cj, ResolvedRelationship as ck, SetLegacyCheckboxOp as cl, SetLegacyDropdownOp as cm, SetTextFormFieldDefaultOp as cn, TabStopWrite as cp, TargetMode as cq, TextFormFieldType as cr, TreeDocOpKind as cs, TreeOpEffect as ct, XmlLimits as cy, XmlNode as cz, ReviewCustomItem as d, VectorShapeComponent as dD, ReviewPosition as e, ReviewRange as f, ReviewRevisionKind as g, RevisionAddress as h, ContentControlType as i, DocTarget as j, RunFormatting as k, Extent as l, ContainerRef as m, ContentControlFilter as n, DocRange as o, Revision as p, DocComment as q, ColorValue as r, ContentControl as s, DocAnchor as t, DocAnchorRange as u, DocLocation as v, DocumentBody as w, ExecErrorCode as x, IndentFormatting as y, ParagraphFlags as z };