@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/dist/global/index.d.ts

@@ -0,0 +1,14 @@
+/*!
+*  filename: index.d.ts
+*  version : 35.1.40
+*  Copyright Syncfusion Inc. 2001 - 2025. All rights reserved.
+*  Use of this code is subject to the terms of our license.
+*  A copy of the current license can be obtained at any time by e-mailing
+*  licensing@syncfusion.com. Any infringement will be prosecuted under
+*  applicable laws. 
+*/
+import * as _docx from '@syncfusion/ej2-docx';
+
+export declare namespace ej {
+    const docx: typeof _docx;
+}

package/features.js

@@ -0,0 +1,4 @@
+/**
+ * features
+ */
+export * from './src/features/index';

package/index.js

@@ -0,0 +1,4 @@
+/**
+ * index
+ */
+export * from './src/index';

package/license

@@ -0,0 +1,10 @@
+Essential JS 2 library is available under the Syncfusion Essential Studio program,  and can be licensed either under the Syncfusion Community License Program or the Syncfusion commercial license.
+
+To be qualified for the Syncfusion Community License Program you must have a gross revenue of less than one (1) million U.S. dollars ($1,000,000.00 USD) per year and have less than five (5) developers in your organization, and agree to be bound by Syncfusion’s terms and conditions. 
+
+Customers who do not qualify for the community license can contact sales@syncfusion.com for commercial licensing options.
+
+Under no circumstances you can use this product without (1) either a Community License or a commercial license and (2) without agreeing and abiding by Syncfusion’s license containing all terms and conditions. 
+
+The Syncfusion license that contains the terms and conditions can be found at 
+https://www.syncfusion.com/content/downloads/syncfusion_license.pdf

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@syncfusion/ej2-docx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "35.1.40",
+  "description": "The EJ2 DOCX library enables the creation, editing, and manipulation of Word documents in JavaScript.",
+  "author": "Syncfusion Inc.",
+  "license": "SEE LICENSE IN license",
+  "main": "./src/index.js",
+  "module": "./index.js",
+  "es2015": "./src/index.js",
+  "typings": "src/index.d.ts",
+  "devDependencies": {},
+  "dependencies": {
+    "@syncfusion/ej2-base": "~35.1.37"
+  },
+  "keywords": [
+    "ej2",
+    "syncfusion",
+    "ej2-docx",
+    "web-components",
+    "javascript",
+    "typescript",
+    "word",
+    "docx",
+    "ooxml",
+    "document-processing"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/syncfusion/ej2-javascript-ui-controls/tree/master/controls/docx"
+  },
+  "sideEffects": false,
+  "homepage": "https://www.syncfusion.com/javascript-ui-controls"
 }

package/src/all.d.ts

@@ -0,0 +1,50 @@
+/**
+ * All-in entry for consumers who want every public API. Importing this module
+ * registers every optional feature handler (R6.1).
+ *
+ * Prefer explicit `@syncfusion/ej2-docx/<feature>` subpaths when bundle size matters.
+ * (Harness still resolves the legacy `@syncfusion/ej2-docx/*` id.)
+ *
+ * @packageDocumentation
+ */
+import './features/document/augmentations';
+import './features/bibliography/index';
+import './features/bookmarks/index';
+import './features/comments/index';
+import './features/content-controls/index';
+import './features/custom-xml/index';
+import './features/drawing/index';
+import './features/editable-ranges/index';
+import './features/fields/index';
+import './features/font-table/index';
+import './features/glossary/index';
+import './features/headers-footers/index';
+import './features/hyperlinks/index';
+import './features/images/public-entry';
+import './features/mail-merge/index';
+import './features/notes/index';
+import './features/numbering/index';
+import './features/ole-object/index';
+import './features/properties/index';
+import './features/revisions/index';
+import './features/sections/index';
+import './features/settings/index';
+import './features/styles/index';
+import './features/tables/index';
+import './features/watermark/index';
+/**
+ * @private
+ * Optional feature subpaths (excludes core `.` and this `./all` entry).
+ */
+export declare const FEATURE_SUBPATHS: string[];
+/** One optional feature export subpath under `@syncfusion/ej2-docx/`.
+  * @private
+  */
+export declare type FeatureSubpath = (typeof FEATURE_SUBPATHS)[number];
+/**
+ * @private
+ * Test hook — clears per-module registration flags and re-registers handlers.
+ */
+export declare function resetAllFeaturesForTests(): void;
+export * from './index';
+export { Hyperlink as RelationshipHyperlink } from './features/hyperlinks/index';

package/src/all.js

@@ -0,0 +1,147 @@
+/**
+ * All-in entry for consumers who want every public API. Importing this module
+ * registers every optional feature handler (R6.1).
+ *
+ * Prefer explicit `@syncfusion/ej2-docx/<feature>` subpaths when bundle size matters.
+ * (Harness still resolves the legacy `@syncfusion/ej2-docx/*` id.)
+ *
+ * @packageDocumentation
+ */
+import './features/document/augmentations';
+import './features/bibliography/index';
+import './features/bookmarks/index';
+import './features/comments/index';
+import './features/content-controls/index';
+import './features/custom-xml/index';
+import './features/drawing/index';
+import './features/editable-ranges/index';
+import './features/fields/index';
+import './features/font-table/index';
+import './features/glossary/index';
+import './features/headers-footers/index';
+import './features/hyperlinks/index';
+// Public images entry loads caption authoring (fields/styles) without putting
+// those optionals on the main package always-on graph.
+import './features/images/public-entry';
+import './features/mail-merge/index';
+import './features/notes/index';
+import './features/numbering/index';
+import './features/ole-object/index';
+import './features/properties/index';
+import './features/revisions/index';
+import './features/sections/index';
+import './features/settings/index';
+import './features/styles/index';
+import './features/tables/index';
+import './features/watermark/index';
+import { registerBibliographyFeature, resetBibliographyFeatureForTests } from './features/bibliography/index';
+import { registerBookmarksFeature, resetBookmarksFeatureForTests } from './features/bookmarks/index';
+import { registerCommentsFeature, resetCommentsFeatureForTests } from './features/comments/index';
+import { registerContentControlsFeature, resetContentControlsFeatureForTests } from './features/content-controls/index';
+import { registerCustomXmlFeature, resetCustomXmlFeatureForTests } from './features/custom-xml/index';
+import { registerDrawingFeature, resetDrawingFeatureForTests } from './features/drawing/parse-register';
+import { registerEditableRangesFeature, resetEditableRangesFeatureForTests } from './features/editable-ranges/index';
+import { registerFieldsFeature, resetFieldsFeatureForTests } from './features/fields/index';
+import { registerFontTableFeature, resetFontTableFeatureForTests } from './features/font-table/index';
+import { registerGlossaryFeature, resetGlossaryFeatureForTests } from './features/glossary/index';
+import { registerHeadersFootersFeature, resetHeadersFootersFeatureForTests } from './features/headers-footers/index';
+import { registerHyperlinksFeature, resetHyperlinksFeatureForTests } from './features/hyperlinks/index';
+import { registerImagesFeature, resetImagesFeatureForTests } from './features/images/index';
+import { registerMailMergeFeature, resetMailMergeFeatureForTests } from './features/mail-merge/index';
+import { registerNotesFeature, resetNotesFeatureForTests } from './features/notes/index';
+import { registerNumberingFeature, resetNumberingFeatureForTests } from './features/numbering/index';
+import { registerOleObjectFeature, resetOleObjectFeatureForTests } from './features/ole-object/index';
+import { registerPropertiesFeature, resetPropertiesFeatureForTests } from './features/properties/index';
+import { registerRevisionsFeature, resetRevisionsFeatureForTests } from './features/revisions/index';
+import { registerSectionsFeature, resetSectionsFeatureForTests } from './features/sections/index';
+import { registerSettingsFeature, resetSettingsFeatureForTests } from './features/settings/index';
+import { registerStylesFeature, resetStylesFeatureForTests } from './features/styles/index';
+import { registerTablesFeature, resetTablesFeatureForTests } from './features/tables/index';
+import { registerWatermarkFeature, resetWatermarkFeatureForTests } from './features/watermark/index';
+/**
+ * @private
+ * Optional feature subpaths (excludes core `.` and this `./all` entry).
+ */
+export var FEATURE_SUBPATHS = [
+    'styles',
+    'numbering',
+    'sections',
+    'headers-footers',
+    'properties',
+    'tables',
+    'images',
+    'hyperlinks',
+    'bookmarks',
+    'fields',
+    'notes',
+    'comments',
+    'revisions',
+    'content-controls',
+    'custom-xml',
+    'settings',
+    'mail-merge',
+    'drawing',
+    'editable-ranges',
+    'bibliography',
+    'glossary',
+    'watermark',
+    'font-table',
+];
+/**
+ * @private
+ * Test hook — clears per-module registration flags and re-registers handlers.
+ */
+export function resetAllFeaturesForTests() {
+    resetSectionsFeatureForTests();
+    resetStylesFeatureForTests();
+    resetFontTableFeatureForTests();
+    resetNumberingFeatureForTests();
+    resetPropertiesFeatureForTests();
+    resetHeadersFootersFeatureForTests();
+    resetTablesFeatureForTests();
+    resetImagesFeatureForTests();
+    resetHyperlinksFeatureForTests();
+    resetBookmarksFeatureForTests();
+    resetFieldsFeatureForTests();
+    resetNotesFeatureForTests();
+    resetCommentsFeatureForTests();
+    resetRevisionsFeatureForTests();
+    resetContentControlsFeatureForTests();
+    resetCustomXmlFeatureForTests();
+    resetSettingsFeatureForTests();
+    resetMailMergeFeatureForTests();
+    resetDrawingFeatureForTests();
+    resetEditableRangesFeatureForTests();
+    resetBibliographyFeatureForTests();
+    resetGlossaryFeatureForTests();
+    resetOleObjectFeatureForTests();
+    resetWatermarkFeatureForTests();
+    registerSectionsFeature();
+    registerStylesFeature();
+    registerFontTableFeature();
+    registerNumberingFeature();
+    registerPropertiesFeature();
+    registerHeadersFootersFeature();
+    registerTablesFeature();
+    registerImagesFeature();
+    registerHyperlinksFeature();
+    registerBookmarksFeature();
+    registerFieldsFeature();
+    registerNotesFeature();
+    registerCommentsFeature();
+    registerRevisionsFeature();
+    registerContentControlsFeature();
+    registerCustomXmlFeature();
+    registerSettingsFeature();
+    registerMailMergeFeature();
+    registerDrawingFeature();
+    registerEditableRangesFeature();
+    registerBibliographyFeature();
+    registerGlossaryFeature();
+    registerWatermarkFeature();
+    registerOleObjectFeature();
+}
+export * from './index';
+// Feature barrels are already exported through `./index`. Only the relationship
+// hyperlink alias is unique to this entry (the field facade owns `Hyperlink`).
+export { Hyperlink as RelationshipHyperlink } from './features/hyperlinks/index';

package/src/core/compat/base64.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Browser base64 via `atob` / `btoa` (DOM lib, TS 3.3).
+ * Does not use Node `Buffer`, which gulp's browser AMD emit cannot type or run.
+ */
+/**
+ * Encode bytes as a standard base64 string (no data-URL prefix).
+ */
+export declare function encodeBase64(bytes: Uint8Array): string;
+/**
+ * Decode a standard base64 payload (whitespace already stripped).
+ * Throws if the payload is not valid base64.
+ */
+export declare function decodeBase64(payload: string): Uint8Array;

package/src/core/compat/base64.js

@@ -0,0 +1,90 @@
+/**
+ * Browser base64 via `atob` / `btoa` (DOM lib, TS 3.3).
+ * Does not use Node `Buffer`, which gulp's browser AMD emit cannot type or run.
+ */
+var BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function encodeWithBtoa(bytes) {
+    if (typeof btoa !== 'function') {
+        return undefined;
+    }
+    var chunkSize = 0x8000;
+    var binary = '';
+    for (var offset = 0; offset < bytes.length; offset += chunkSize) {
+        var end = Math.min(offset + chunkSize, bytes.length);
+        var slice = '';
+        for (var i = offset; i < end; i++) {
+            slice += String.fromCharCode(bytes[i]);
+        }
+        binary += slice;
+    }
+    return btoa(binary);
+}
+function decodeWithAtob(payload) {
+    if (typeof atob !== 'function') {
+        return undefined;
+    }
+    var binary = atob(payload);
+    var out = new Uint8Array(binary.length);
+    for (var i = 0; i < binary.length; i++) {
+        out[i] = binary.charCodeAt(i) & 0xff;
+    }
+    return out;
+}
+/**
+ * Encode bytes as a standard base64 string (no data-URL prefix).
+ */
+export function encodeBase64(bytes) {
+    var fromDom = encodeWithBtoa(bytes);
+    if (fromDom !== undefined) {
+        return fromDom;
+    }
+    var out = '';
+    for (var i = 0; i < bytes.length; i += 3) {
+        var b0 = bytes[i];
+        var b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+        var b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        var triple = (b0 << 16) | (b1 << 8) | b2;
+        out += BASE64_ALPHABET[(triple >> 18) & 63];
+        out += BASE64_ALPHABET[(triple >> 12) & 63];
+        out += i + 1 < bytes.length ? BASE64_ALPHABET[(triple >> 6) & 63] : '=';
+        out += i + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] : '=';
+    }
+    return out;
+}
+/**
+ * Decode a standard base64 payload (whitespace already stripped).
+ * Throws if the payload is not valid base64.
+ */
+export function decodeBase64(payload) {
+    var fromDom = decodeWithAtob(payload);
+    if (fromDom !== undefined) {
+        return fromDom;
+    }
+    if (payload.length % 4 !== 0) {
+        throw new Error('Invalid base64 payload');
+    }
+    var padChar = payload.length === 0 ? '' : payload.charAt(payload.length - 1);
+    var padChar2 = payload.length < 2 ? '' : payload.charAt(payload.length - 2);
+    var padding = padChar2 === '=' && padChar === '=' ? 2 : padChar === '=' ? 1 : 0;
+    var outLength = (payload.length / 4) * 3 - padding;
+    var out = new Uint8Array(outLength);
+    var written = 0;
+    for (var i = 0; i < payload.length; i += 4) {
+        var c0 = BASE64_ALPHABET.indexOf(payload.charAt(i));
+        var c1 = BASE64_ALPHABET.indexOf(payload.charAt(i + 1));
+        var c2 = payload.charAt(i + 2) === '=' ? 0 : BASE64_ALPHABET.indexOf(payload.charAt(i + 2));
+        var c3 = payload.charAt(i + 3) === '=' ? 0 : BASE64_ALPHABET.indexOf(payload.charAt(i + 3));
+        if (c0 < 0 || c1 < 0 || (payload.charAt(i + 2) !== '=' && c2 < 0) || (payload.charAt(i + 3) !== '=' && c3 < 0)) {
+            throw new Error('Invalid base64 payload');
+        }
+        var triple = (c0 << 18) | (c1 << 12) | (c2 << 6) | c3;
+        out[written++] = (triple >> 16) & 0xff;
+        if (payload.charAt(i + 2) !== '=' && written < outLength) {
+            out[written++] = (triple >> 8) & 0xff;
+        }
+        if (payload.charAt(i + 3) !== '=' && written < outLength) {
+            out[written++] = triple & 0xff;
+        }
+    }
+    return out;
+}

package/src/core/compat/object-compat.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ES5/ES2015-safe replacements for `Object.values` / `Object.entries`.
+ *
+ * The project's TypeScript `lib` is intentionally capped at ES5 + ES2015
+ * (see `tsconfig.json`); `Object.values` / `Object.entries` are ES2017
+ * (`lib.es2017.object.d.ts`) and must not be relied on directly. These
+ * helpers provide the same semantics using only `Object.keys` (ES5).
+ *
+ * @private
+ */
+/**
+ * ES5-safe equivalent of `Object.values`.
+ *
+ * @param obj - Plain object whose own enumerable string-keyed values are collected.
+ * @returns Array of the object's own enumerable property values, in `Object.keys` order.
+ * @private
+ */
+export declare function objectValues<T>(obj: {
+    [key: string]: T;
+}): T[];
+/**
+ * ES5-safe equivalent of `Object.entries`.
+ *
+ * @param obj - Plain object whose own enumerable string-keyed entries are collected.
+ * @returns Array of `[key, value]` tuples, in `Object.keys` order.
+ * @private
+ */
+export declare function objectEntries<T>(obj: {
+    [key: string]: T;
+}): Array<[string, T]>;

package/src/core/compat/object-compat.js

@@ -0,0 +1,40 @@
+/**
+ * ES5/ES2015-safe replacements for `Object.values` / `Object.entries`.
+ *
+ * The project's TypeScript `lib` is intentionally capped at ES5 + ES2015
+ * (see `tsconfig.json`); `Object.values` / `Object.entries` are ES2017
+ * (`lib.es2017.object.d.ts`) and must not be relied on directly. These
+ * helpers provide the same semantics using only `Object.keys` (ES5).
+ *
+ * @private
+ */
+/**
+ * ES5-safe equivalent of `Object.values`.
+ *
+ * @param obj - Plain object whose own enumerable string-keyed values are collected.
+ * @returns Array of the object's own enumerable property values, in `Object.keys` order.
+ * @private
+ */
+export function objectValues(obj) {
+    var keys = Object.keys(obj);
+    var result = [];
+    for (var i = 0; i < keys.length; i += 1) {
+        result.push(obj[keys[i]]);
+    }
+    return result;
+}
+/**
+ * ES5-safe equivalent of `Object.entries`.
+ *
+ * @param obj - Plain object whose own enumerable string-keyed entries are collected.
+ * @returns Array of `[key, value]` tuples, in `Object.keys` order.
+ * @private
+ */
+export function objectEntries(obj) {
+    var keys = Object.keys(obj);
+    var result = [];
+    for (var i = 0; i < keys.length; i += 1) {
+        result.push([keys[i], obj[keys[i]]]);
+    }
+    return result;
+}

package/src/core/compat/sha256.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Browser SHA-256 (FIPS 180-4) for content-addressable media dedupe.
+ * Synchronous and dependency-free so classic AMD / gulp emit (TS 3.3, es5)
+ * does not import Node `crypto`, which browsers cannot load.
+ */
+/**
+ * Lowercase hex SHA-256 of `data`.
+ */
+export declare function sha256Hex(data: Uint8Array): string;

package/src/core/compat/sha256.js

@@ -0,0 +1,98 @@
+/**
+ * Browser SHA-256 (FIPS 180-4) for content-addressable media dedupe.
+ * Synchronous and dependency-free so classic AMD / gulp emit (TS 3.3, es5)
+ * does not import Node `crypto`, which browsers cannot load.
+ */
+var K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+function rotr(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+/**
+ * Lowercase hex SHA-256 of `data`.
+ */
+export function sha256Hex(data) {
+    var bitLength = data.length * 8;
+    var withPadding = data.length + 1 + 8;
+    var paddedLength = (withPadding + 63) & ~63;
+    var padded = new Uint8Array(paddedLength);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    var view = new DataView(padded.buffer);
+    // High 32 bits stay 0: media payloads are far below 512 MiB.
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    var h0 = 0x6a09e667;
+    var h1 = 0xbb67ae85;
+    var h2 = 0x3c6ef372;
+    var h3 = 0xa54ff53a;
+    var h4 = 0x510e527f;
+    var h5 = 0x9b05688c;
+    var h6 = 0x1f83d9ab;
+    var h7 = 0x5be0cd19;
+    var w = new Array(64);
+    for (var offset = 0; offset < paddedLength; offset += 64) {
+        for (var i = 0; i < 16; i++) {
+            w[i] = view.getUint32(offset + i * 4, false);
+        }
+        for (var i = 16; i < 64; i++) {
+            var s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            var s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+        }
+        var a = h0;
+        var b = h1;
+        var c = h2;
+        var d = h3;
+        var e = h4;
+        var f = h5;
+        var g = h6;
+        var h = h7;
+        for (var i = 0; i < 64; i++) {
+            var s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            var ch = (e & f) ^ (~e & g);
+            var temp1 = (h + s1 + ch + K[i] + w[i]) | 0;
+            var s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            var maj = (a & b) ^ (a & c) ^ (b & c);
+            var temp2 = (s0 + maj) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) | 0;
+        }
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+    var out = new Uint8Array(32);
+    var outView = new DataView(out.buffer);
+    outView.setUint32(0, h0, false);
+    outView.setUint32(4, h1, false);
+    outView.setUint32(8, h2, false);
+    outView.setUint32(12, h3, false);
+    outView.setUint32(16, h4, false);
+    outView.setUint32(20, h5, false);
+    outView.setUint32(24, h6, false);
+    outView.setUint32(28, h7, false);
+    var hex = '';
+    for (var i = 0; i < out.length; i++) {
+        hex += (out[i] < 16 ? '0' : '') + out[i].toString(16);
+    }
+    return hex;
+}

package/src/core/errors/docx-error.d.ts

@@ -0,0 +1,89 @@
+import { DocxErrorCode } from './error-codes';
+/**
+ * Optional cause bag for {@link DocxError} constructors.
+ * Kept local so product emit does not depend on ej2-xlsx typings.
+ * Aligns with the global ambient `ErrorOptions` in `src/ts33-compat.ts`.
+ *
+ * @private
+ */
+export interface ErrorOptions {
+    cause?: unknown;
+}
+/**
+ * Base error for every library failure. Consumers switch on {@link DocxError.code}, never on message text.
+ *
+ * @private
+ */
+export declare class DocxError extends Error {
+    /**
+     * Stable machine-readable identifier.
+     */
+    readonly code: DocxErrorCode;
+    /**
+     * Underlying cause of this error, when known. Assigned explicitly:
+     * the pinned TypeScript 3.3.1 lib types the Error constructor with a
+     * message parameter only, so `cause` cannot flow through `super`.
+     */
+    readonly cause?: unknown;
+    constructor(code: DocxErrorCode, message: string, options?: ErrorOptions);
+}
+/**
+ * ZIP or OPC package problems.
+ *
+ * @private
+ */
+export declare class PackageError extends DocxError {
+}
+/**
+ * Well-formedness, DTD, or XML limit failures.
+ *
+ * @private
+ */
+export declare class XmlError extends DocxError {
+}
+/**
+ * Security-limit and untrusted-input failures.
+ *
+ * @private
+ */
+export declare class SecurityError extends DocxError {
+}
+/**
+ * Markup Compatibility MustUnderstand and related failures.
+ *
+ * @private
+ */
+export declare class MarkupCompatibilityError extends DocxError {
+}
+/**
+ * Exhaustiveness failure for a content union the compiler should have rejected.
+ *
+ * @private
+ */
+export declare class UnsupportedContentError extends DocxError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Mutation of an object after it was removed from its document.
+ *
+ * @private
+ */
+export declare class DetachedObjectError extends DocxError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * API argument is missing or empty where a value is required.
+ *
+ * @private
+ */
+export declare class InvalidArgumentError extends DocxError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Underlying filesystem or byte I/O failure wrapped for consumers.
+ *
+ * @private
+ */
+export declare class IoError extends DocxError {
+    constructor(message: string, options?: ErrorOptions);
+}