@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/settings/web-settings.d.ts

@@ -0,0 +1,88 @@
+import { WordDocument } from '../document/document';
+import { FeaturePackagePart } from '../document/feature-package-part';
+/**
+ * @private
+ * Transitional web settings relationship (ECMA-376-4 §9.2.13). */
+export declare const WEB_SETTINGS_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings";
+/**
+ * @private
+ * Strict web settings relationship (ECMA-376-1 §11.3.13). */
+export declare const STRICT_WEB_SETTINGS_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/webSettings";
+/**
+ * @private
+ * ECMA-376-1 §11.3.13 Web Settings content type. */
+export declare const WEB_SETTINGS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml";
+/**
+ * @private
+ */
+export declare const WEB_SETTINGS_PART_NAME: import("../../core/opc/part-name").PartName;
+interface WebSettingsMetadata {
+    readonly encoding: string | undefined;
+    readonly hasFrameset: boolean;
+    readonly divCount: number;
+    readonly optimizeForBrowserTarget: string | undefined;
+}
+/**
+ * In-memory Web Settings part (`word/webSettings.xml`).
+ *
+ * @private
+ */
+export declare class WebSettingsPart implements FeaturePackagePart {
+    private readonly bytes;
+    private readonly metadata;
+    private readonly dirty;
+    /**
+     * @private
+     */
+    constructor(bytes: Uint8Array | undefined, metadata: WebSettingsMetadata, dirty: boolean);
+    /**
+     * `w:encoding/@w:val`, or `undefined` when absent or the part is missing.
+     *
+     * @public
+     */
+    encoding(): string | undefined;
+    /**
+     * Whether `w:frameset` is present under `w:webSettings`.
+     *
+     * @public
+     */
+    hasFrameset(): boolean;
+    /**
+     * Count of `w:divs/w:div` children.
+     *
+     * @public
+     */
+    divCount(): number;
+    /**
+     * `w:optimizeForBrowser/@w:target`, or `undefined` when absent.
+     *
+     * @public
+     */
+    optimizeForBrowserTarget(): string | undefined;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    serialize(): Uint8Array;
+}
+/**
+ * @private
+ * Test hook */
+export declare function resetWebSettingsFeatureForTests(): void;
+/**
+ * @private
+ * Register the web settings package-part handler. Idempotent. */
+export declare function registerWebSettingsFeature(): void;
+/**
+ * Web settings catalog for a document. Requires {@link registerSettingsFeature} or
+ * {@link registerWebSettingsFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the web settings handler was not registered before load.
+ *
+ * @private
+ */
+export declare function webSettingsFor(document: WordDocument): WebSettingsPart;
+export {};

package/src/features/settings/web-settings.js

@@ -0,0 +1,227 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { DocxError } from '../../core/errors/docx-error';
+import { elementChildren, isWml } from '../document/wml';
+import { partName } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeaturePartHandler, } from '../../core/registry/index';
+import { parseXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+var WEB_SETTINGS = featureId('web-settings');
+/**
+ * @private
+ * Transitional web settings relationship (ECMA-376-4 §9.2.13). */
+export var WEB_SETTINGS_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings';
+/**
+ * @private
+ * Strict web settings relationship (ECMA-376-1 §11.3.13). */
+export var STRICT_WEB_SETTINGS_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/webSettings';
+/**
+ * @private
+ * ECMA-376-1 §11.3.13 Web Settings content type. */
+export var WEB_SETTINGS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml';
+/**
+ * @private
+ */
+export var WEB_SETTINGS_PART_NAME = partName('/word/webSettings.xml');
+var utf8Decoder = new TextDecoder('utf-8');
+var EMPTY_METADATA = {
+    encoding: undefined,
+    hasFrameset: false,
+    divCount: 0,
+    optimizeForBrowserTarget: undefined,
+};
+function wmlAttribute(element, localName) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === WML_TRANSITIONAL_NAMESPACE || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function parseWebSettingsMetadata(root) {
+    var e_1, _a, e_2, _b;
+    if (!isWml(root, 'webSettings')) {
+        return undefined;
+    }
+    var encoding;
+    var hasFrameset = false;
+    var divCount = 0;
+    var optimizeForBrowserTarget;
+    try {
+        for (var _c = __values(elementChildren(root)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (isWml(child, 'encoding')) {
+                encoding = wmlAttribute(child, 'val');
+                continue;
+            }
+            if (isWml(child, 'frameset')) {
+                hasFrameset = true;
+                continue;
+            }
+            if (isWml(child, 'divs')) {
+                try {
+                    for (var _e = __values(elementChildren(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var div = _f.value;
+                        if (isWml(div, 'div')) {
+                            divCount += 1;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                continue;
+            }
+            if (isWml(child, 'optimizeForBrowser')) {
+                optimizeForBrowserTarget = wmlAttribute(child, 'target');
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { encoding: encoding, hasFrameset: hasFrameset, divCount: divCount, optimizeForBrowserTarget: optimizeForBrowserTarget };
+}
+function parseWebSettingsMetadataFromBytes(bytes) {
+    var root = parseXml(utf8Decoder.decode(bytes));
+    return parseWebSettingsMetadata(root);
+}
+/**
+ * In-memory Web Settings part (`word/webSettings.xml`).
+ *
+ * @private
+ */
+var WebSettingsPart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function WebSettingsPart(bytes, metadata, dirty) {
+        this.bytes = bytes;
+        this.metadata = metadata;
+        this.dirty = dirty;
+    }
+    /**
+     * `w:encoding/@w:val`, or `undefined` when absent or the part is missing.
+     *
+     * @public
+     */
+    WebSettingsPart.prototype.encoding = function () {
+        return this.metadata.encoding;
+    };
+    /**
+     * Whether `w:frameset` is present under `w:webSettings`.
+     *
+     * @public
+     */
+    WebSettingsPart.prototype.hasFrameset = function () {
+        return this.metadata.hasFrameset;
+    };
+    /**
+     * Count of `w:divs/w:div` children.
+     *
+     * @public
+     */
+    WebSettingsPart.prototype.divCount = function () {
+        return this.metadata.divCount;
+    };
+    /**
+     * `w:optimizeForBrowser/@w:target`, or `undefined` when absent.
+     *
+     * @public
+     */
+    WebSettingsPart.prototype.optimizeForBrowserTarget = function () {
+        return this.metadata.optimizeForBrowserTarget;
+    };
+    /**
+     * @private
+     */
+    WebSettingsPart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    WebSettingsPart.prototype.serialize = function () {
+        if (this.bytes !== undefined) {
+            return this.bytes;
+        }
+        return new Uint8Array(0);
+    };
+    return WebSettingsPart;
+}());
+export { WebSettingsPart };
+function loadWebSettingsPart(part) {
+    var __ts33_0;
+    if (part === undefined) {
+        return new WebSettingsPart(undefined, __assign({}, EMPTY_METADATA), false);
+    }
+    var metadata = ((__ts33_0 = parseWebSettingsMetadataFromBytes(part.data)), __ts33_0 != null ? __ts33_0 : __assign({}, EMPTY_METADATA));
+    return new WebSettingsPart(part.data, metadata, false);
+}
+var webSettingsRegistered = false;
+/**
+ * @private
+ * Test hook */
+export function resetWebSettingsFeatureForTests() {
+    webSettingsRegistered = false;
+}
+/**
+ * @private
+ * Register the web settings package-part handler. Idempotent. */
+export function registerWebSettingsFeature() {
+    if (webSettingsRegistered) {
+        return;
+    }
+    webSettingsRegistered = true;
+    registerFeature({ id: WEB_SETTINGS });
+    registerFeaturePartHandler({
+        featureId: WEB_SETTINGS,
+        relationshipTypes: [WEB_SETTINGS_RELATIONSHIP_TYPE, STRICT_WEB_SETTINGS_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'webSettings.xml',
+        partName: WEB_SETTINGS_PART_NAME,
+        contentType: WEB_SETTINGS_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadWebSettingsPart(part);
+        },
+    });
+}
+/**
+ * Web settings catalog for a document. Requires {@link registerSettingsFeature} or
+ * {@link registerWebSettingsFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the web settings handler was not registered before load.
+ *
+ * @private
+ */
+export function webSettingsFor(document) {
+    registerWebSettingsFeature();
+    var part = document.featurePart(WEB_SETTINGS);
+    if (part === undefined || !(part instanceof WebSettingsPart)) {
+        throw new DocxError('feature/not-registered', 'Web settings part was not loaded; call registerSettingsFeature() before WordDocument.open');
+    }
+    return part;
+}

package/src/features/settings/zoom.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `w:zoom` DOM (`CT_Zoom`, Transitional `wml.xsd`).
+ *
+ * Models the view magnification applied to a document. `percent` is the
+ * canonical zoom percentage (e.g. 100). `val` qualifies the zoom type when
+ * present (none | fullPage | bestFit | textFit).
+ *
+ * @private
+ */
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * `ST_Zoom` wire tokens for `w:zoom/@w:val` (Transitional `wml.xsd`).
+ *
+ * `"none"` means the numeric percent is the sole control.
+ *
+ * @public
+ */
+export declare enum ZoomType {
+    /** Numeric percent is the sole zoom control. */
+    None = "none",
+    /** Fit the full page in the window. */
+    FullPage = "fullPage",
+    /** Best fit for the window. */
+    BestFit = "bestFit",
+    /** Fit page width to text. */
+    TextFit = "textFit"
+}
+/**
+ * @private
+ * Wire string form of {@link ZoomType} (same tokens as the public enum).
+ */
+export declare type ZoomTypeWire = 'none' | 'fullPage' | 'bestFit' | 'textFit';
+/**
+ * First-class `w:zoom` node (`CT_Zoom`).
+ *
+ * ECMA-376-1 §17.15.1.93 — `w:zoom`
+ *
+ * Kept public because {@link SettingsPart.zoom} / {@link SettingsPart.setZoom} use it (R7.3).
+ *
+ * @private
+ */
+export declare class ZoomSettings {
+    private zoomType;
+    private zoomPercent;
+    private constructor();
+    /**
+     * @private
+     */
+    static fromElement(element: OpenXmlElement): ZoomSettings;
+    /**
+     * Create a new `ZoomSettings` from explicit values.
+     * @private
+     */
+    static create(percent: number, val?: ZoomTypeWire | ZoomType): ZoomSettings;
+    /**
+     * `w:zoom/@w:val` — zoom type qualifier, or `undefined` when absent.
+     * @private
+     */
+    type(): ZoomTypeWire | undefined;
+    /**
+     * Mutate `w:zoom/@w:val`.
+     * @private
+     */
+    setType(val: ZoomTypeWire | ZoomType | undefined): void;
+    /**
+     * `w:zoom/@w:percent` — numeric zoom percentage, or `undefined` when absent.
+     * @private
+     */
+    percent(): number | undefined;
+    /**
+     * Mutate `w:zoom/@w:percent`.
+     * @private
+     */
+    setPercent(value: number | undefined): void;
+    /**
+     * @private
+     */
+    serialize(): OpenXmlElement;
+}

package/src/features/settings/zoom.js

@@ -0,0 +1,147 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+/**
+ * `w:zoom` DOM (`CT_Zoom`, Transitional `wml.xsd`).
+ *
+ * Models the view magnification applied to a document. `percent` is the
+ * canonical zoom percentage (e.g. 100). `val` qualifies the zoom type when
+ * present (none | fullPage | bestFit | textFit).
+ *
+ * @private
+ */
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { wmlAttr, wmlElement } from '../document/wml';
+/**
+ * `ST_Zoom` wire tokens for `w:zoom/@w:val` (Transitional `wml.xsd`).
+ *
+ * `"none"` means the numeric percent is the sole control.
+ *
+ * @public
+ */
+export var ZoomType;
+(function (ZoomType) {
+    /** Numeric percent is the sole zoom control. */
+    ZoomType["None"] = "none";
+    /** Fit the full page in the window. */
+    ZoomType["FullPage"] = "fullPage";
+    /** Best fit for the window. */
+    ZoomType["BestFit"] = "bestFit";
+    /** Fit page width to text. */
+    ZoomType["TextFit"] = "textFit";
+})(ZoomType || (ZoomType = {}));
+function isZoomTypeWire(value) {
+    return value === 'none' || value === 'fullPage' || value === 'bestFit' || value === 'textFit';
+}
+/**
+ * First-class `w:zoom` node (`CT_Zoom`).
+ *
+ * ECMA-376-1 §17.15.1.93 — `w:zoom`
+ *
+ * Kept public because {@link SettingsPart.zoom} / {@link SettingsPart.setZoom} use it (R7.3).
+ *
+ * @private
+ */
+var ZoomSettings = /** @class */ (function () {
+    function ZoomSettings(zoomType, zoomPercent) {
+        this.zoomType = zoomType;
+        this.zoomPercent = zoomPercent;
+    }
+    /**
+     * @private
+     */
+    ZoomSettings.fromElement = function (element) {
+        var e_1, _a;
+        var zoomType;
+        var zoomPercent;
+        try {
+            for (var _b = __values(element.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                if (attr.localName === 'val' &&
+                    (attr.namespaceUri === WML_TRANSITIONAL_NAMESPACE || attr.namespaceUri === '')) {
+                    var v = attr.value;
+                    if (isZoomTypeWire(v)) {
+                        zoomType = v;
+                    }
+                }
+                if (attr.localName === 'percent' &&
+                    (attr.namespaceUri === WML_TRANSITIONAL_NAMESPACE || attr.namespaceUri === '')) {
+                    var n = Number(attr.value);
+                    if (!Number.isNaN(n)) {
+                        zoomPercent = n;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return new ZoomSettings(zoomType, zoomPercent);
+    };
+    /**
+     * Create a new `ZoomSettings` from explicit values.
+     * @private
+     */
+    ZoomSettings.create = function (percent, val) {
+        var wire = val === undefined ? undefined : (typeof val === 'string' ? val : val);
+        return new ZoomSettings(wire, percent);
+    };
+    /**
+     * `w:zoom/@w:val` — zoom type qualifier, or `undefined` when absent.
+     * @private
+     */
+    ZoomSettings.prototype.type = function () {
+        return this.zoomType;
+    };
+    /**
+     * Mutate `w:zoom/@w:val`.
+     * @private
+     */
+    ZoomSettings.prototype.setType = function (val) {
+        if (val === undefined) {
+            this.zoomType = undefined;
+            return;
+        }
+        this.zoomType = typeof val === 'string' ? val : val;
+    };
+    /**
+     * `w:zoom/@w:percent` — numeric zoom percentage, or `undefined` when absent.
+     * @private
+     */
+    ZoomSettings.prototype.percent = function () {
+        return this.zoomPercent;
+    };
+    /**
+     * Mutate `w:zoom/@w:percent`.
+     * @private
+     */
+    ZoomSettings.prototype.setPercent = function (value) {
+        this.zoomPercent = value;
+    };
+    /**
+     * @private
+     */
+    ZoomSettings.prototype.serialize = function () {
+        var attrs = [];
+        if (this.zoomType !== undefined) {
+            attrs.push(wmlAttr('val', this.zoomType));
+        }
+        if (this.zoomPercent !== undefined) {
+            attrs.push(wmlAttr('percent', String(this.zoomPercent)));
+        }
+        return wmlElement('zoom', { attributes: attrs });
+    };
+    return ZoomSettings;
+}());
+export { ZoomSettings };

package/src/features/styles/builtin-catalog.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Centralized built-in style catalog — immutable templates for every built-in
+ * style the library recognizes, references, or requires.
+ *
+ * Design (`docs/specs/styles-builtin-definitions-catalog.md` §2):
+ * - Templates are structured data (`BuiltinStyleTemplate`), never serialized
+ *   XML strings — the serializer consumes the `DocxStyle` graph produced by
+ *   {@link instantiateBuiltinStyle}.
+ * - The catalog is built once at module load into frozen entries held in a
+ *   `ReadonlyMap`; templates are shared but never mutated (deep-cloned on
+ *   every instantiation).
+ * - Formatting payloads reuse the modeled property subsets from
+ *   `run-properties.ts` / `paragraph-properties.ts` (single source of truth for
+ *   parse/serialize/clone) — no duplicate formatting models.
+ *
+ * Value sourcing (never-invent-OOXML, spec §2.5):
+ * - `Normal`, `Heading1`, `Heading2` — normative, mandated by the requirement
+ *   (spec §2.2–§2.4): Times New Roman 12 pt; Arial 16 pt bold / Arial 14 pt
+ *   bold-italic, keepNext, spacing before 240 after 60, outlineLvl 0/1.
+ * - Style ID ↔ display name and style *type* for every entry —
+ *   `[MS-OI29500]` §2.1.238/§2.1.242 Word reserved built-in style name table
+ *   (Word reserves these names with these types).
+ * - Heading 3–9 shells (basedOn/next/qFormat/keepNext/240/60/outlineLvl)
+ *   follow the mandated heading shell (spec §2.5) with the Word heading
+ *   scale (Arial, bold, 13/12/11/11/11/11/11 pt per level).
+ * - `DefaultParagraphFont`, `TableNormal`, `NoList`, `TableGrid`,
+ *   `Hyperlink` — re-sourced from the shipped Word "Hello World" create-path
+ *   evidence (`default-styles.ts`, TASK-8027).
+ * - Other character/paragraph defaults (`Strong` bold, `Emphasis` italic,
+ *   reference styles superscript, `FollowedHyperlink` 800080 + single
+ *   underline, `NoSpacing` suppresses doc-default spacing) — semantic
+ *   defaults from the style names' documented meaning (ECMA-376-1 §17.7)
+ *   encoded as the catalog's built-in default; a document's parsed
+ *   definition always wins (spec §11.1).
+ *
+ * @private
+ */
+import { OpenXmlElement } from '../../core/xml/index';
+import { ModeledParagraphProperties } from './paragraph-properties';
+import { ModeledRunProperties } from './run-properties';
+import { DocxStyle, DocxStyleType } from './style';
+/**
+ * One immutable built-in style template. Instances are created exclusively
+ * via {@link instantiateBuiltinStyle}, which deep-clones every nested value.
+ *
+ * @private
+ */
+export interface BuiltinStyleTemplate {
+    /** Canonical `w:styleId` (e.g. "Heading1"). */
+    readonly styleId: string;
+    /** Canonical `w:name/@w:val` display name (e.g. "Heading 1"). */
+    readonly displayName: string;
+    readonly type: DocxStyleType;
+    /** `@w:default` — default style for its type. */
+    readonly isDefault?: boolean;
+    /** Canonical ID of the base style (`w:basedOn`). */
+    readonly basedOn?: string;
+    /** Canonical ID of the next-paragraph style (`w:next`). */
+    readonly next?: string;
+    /** Canonical ID of the linked style of the other type (`w:link`). */
+    readonly link?: string;
+    /** `w:uiPriority/@w:val`. */
+    readonly uiPriority?: number;
+    /** `w:qFormat` — quick-format (style gallery) state. */
+    readonly isQuickFormat?: boolean;
+    /** `w:semiHidden`. */
+    readonly isSemiHidden?: boolean;
+    /** `w:unhideWhenUsed`. */
+    readonly unhideWhenUsed?: boolean;
+    /** → `w:pPr` (only this style's own deltas; inheritance stays via basedOn). */
+    readonly paragraphFormatting?: ModeledParagraphProperties;
+    /** → `w:rPr`. */
+    readonly characterFormatting?: ModeledRunProperties;
+    /**
+     * `w:tblPr` payload for table styles, carried as typed `wmlElement` parts
+     * (the shipped create-path structure — see `TableStyleFormatting` note,
+     * spec §2.1). Undefined for non-table styles.
+     */
+    readonly tableFormatting?: ReadonlyArray<OpenXmlElement>;
+}
+/**
+ * Normalize a style name or ID for lookup: lowercase, collapse internal
+ * whitespace, strip it entirely. "Heading 1", "heading1", "HEADING 1" all
+ * normalize identically.
+ *
+ * @private
+ */
+export declare function normalizeStyleName(name: string): string;
+/**
+ * Public built-in paragraph style identifiers (canonical OOXML `w:styleId` values).
+ *
+ * Prefer these constants with {@link Paragraph.applyStyle} so callers do not
+ * hard-code style ids. Member values are the wire style ids (e.g. `Heading1`).
+ *
+ * @public
+ */
+export declare const BuiltInStyle: {
+    Normal: "Normal";
+    Heading1: "Heading1";
+    Heading2: "Heading2";
+};
+/** One of the {@link BuiltInStyle} canonical paragraph style ids. */
+export declare type BuiltInStyle = (typeof BuiltInStyle)[keyof typeof BuiltInStyle];
+/**
+ * Public built-in table style identifiers (canonical OOXML `w:styleId` values).
+ *
+ * Prefer these constants with {@link Table.applyStyle} so callers do not hard-code
+ * style ids. Member values are the wire style ids (e.g. `LightShading-Accent1`).
+ *
+ * @public
+ */
+export declare const BuiltinTableStyle: {
+    TableNormal: "TableNormal";
+    TableGrid: "TableGrid";
+    LightShading: "LightShading";
+    LightShadingAccent1: "LightShading-Accent1";
+    LightShadingAccent2: "LightShading-Accent2";
+    LightShadingAccent3: "LightShading-Accent3";
+    LightShadingAccent4: "LightShading-Accent4";
+    LightShadingAccent5: "LightShading-Accent5";
+    LightShadingAccent6: "LightShading-Accent6";
+};
+/** One of the {@link BuiltinTableStyle} canonical style ids. */
+export declare type BuiltinTableStyle = (typeof BuiltinTableStyle)[keyof typeof BuiltinTableStyle];
+/**
+ * Look up a template by canonical style ID.
+ * @private
+ */
+export declare function getBuiltinStyleTemplate(styleId: string): BuiltinStyleTemplate | undefined;
+/**
+ * Look up a template by display name (normalization applied).
+ * @private
+ */
+export declare function getBuiltinStyleTemplateByDisplayName(name: string): BuiltinStyleTemplate | undefined;
+/**
+ * Canonical ID for any known built-in form: canonical ID itself, or the
+ * canonical ID whose display name matches (normalized). `undefined` for
+ * unknown values — no best-effort guessing.
+ *
+ * @private
+ */
+export declare function canonicalBuiltinStyleId(nameOrId: string): string | undefined;
+/**
+ * Frozen snapshot for tests and tooling.
+ * @private
+ */
+export declare function listBuiltinStyleTemplates(): ReadonlyArray<BuiltinStyleTemplate>;
+/**
+ * Instantiate a catalog template as a document-owned `DocxStyle`: deep-clones
+ * the shell fields and every nested formatting object into typed `wmlElement`
+ * children (via the modeled payload serializers), sharing nothing with the
+ * template, the catalog, or any other instantiation.
+ *
+ * Dependency styles (`basedOn`/`next`/`link`) are referenced by canonical ID
+ * and resolved by the resolver (TASK-8066), not here.
+ *
+ * @private
+ */
+export declare function instantiateBuiltinStyle(template: BuiltinStyleTemplate): DocxStyle;