@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/styles/style-format-bridge.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Bridges immutable Modeled* transfer bags and live CharacterFormat /
+ * ParagraphFormat snapshots.
+ *
+ * Modeled bags remain catalog / resolver transfer values only. Live Style
+ * facades own mutable w:rPr / w:pPr state. Conversion is always via the
+ * existing parse/serialize codecs so extras and full CF/PF surfaces stay
+ * coherent (Style_Architecture_change.txt §8–9).
+ *
+ * @private
+ */
+import { CharacterFormatSnapshot } from '../document/character-format';
+import { ParagraphFormatSnapshot } from '../document/paragraph-format';
+import { OpenXmlElement } from '../../core/xml/index';
+import { ModeledParagraphProperties } from './paragraph-properties';
+import { ModeledRunProperties } from './run-properties';
+/**
+ * Convert a modeled run-properties bag into a CharacterFormat hydrate snapshot.
+ * Uses serialize → parse so theme fonts, underline, lang, and size units match
+ * the body CF codec.
+ *
+ * @private
+ */
+export declare function modeledRunPropertiesToCharacterSnapshot(properties: ModeledRunProperties): CharacterFormatSnapshot;
+/**
+ * Convert a live CharacterFormat snapshot into a modeled run-properties bag for
+ * resolver merge / theme resolution. Unsupported children stay on the snapshot
+ * (`rPrExtra`) and are not reduced into ModeledRunProperties.
+ *
+ * @private
+ */
+export declare function characterSnapshotToModeledRunProperties(snapshot: CharacterFormatSnapshot): ModeledRunProperties;
+/**
+ * Convert a modeled paragraph-properties bag into a ParagraphFormat snapshot.
+ *
+ * @private
+ */
+export declare function modeledParagraphPropertiesToParagraphSnapshot(properties: ModeledParagraphProperties): ParagraphFormatSnapshot;
+/**
+ * Convert a live ParagraphFormat snapshot into a modeled paragraph-properties bag.
+ *
+ * @private
+ */
+export declare function paragraphSnapshotToModeledParagraphProperties(snapshot: ParagraphFormatSnapshot): ModeledParagraphProperties;
+/**
+ * Parse full CF snapshot from an optional `w:rPr` element (style body).
+ *
+ * @private
+ */
+export declare function characterSnapshotFromRPr(rPr: OpenXmlElement | undefined): CharacterFormatSnapshot;
+/**
+ * Parse full PF snapshot from an optional `w:pPr` element (style body).
+ * Style-level `w:pPr` must not carry `w:pStyle` / `w:rPr` / `w:sectPr` as
+ * paragraph-owned children — the PF parser already skips those names.
+ *
+ * @private
+ */
+export declare function paragraphSnapshotFromPPr(pPr: OpenXmlElement | undefined): ParagraphFormatSnapshot;
+/**
+ * Empty modeled run-properties bag (resolver / package defaults).
+ *
+ * @private
+ */
+export declare function emptyModeledRunProperties(): ModeledRunProperties;

package/src/features/styles/style-format-bridge.js

@@ -0,0 +1,100 @@
+/**
+ * Bridges immutable Modeled* transfer bags and live CharacterFormat /
+ * ParagraphFormat snapshots.
+ *
+ * Modeled bags remain catalog / resolver transfer values only. Live Style
+ * facades own mutable w:rPr / w:pPr state. Conversion is always via the
+ * existing parse/serialize codecs so extras and full CF/PF surfaces stay
+ * coherent (Style_Architecture_change.txt §8–9).
+ *
+ * @private
+ */
+import { buildRPrChildrenFromSnapshot, parseCharacterFormat, } from '../document/character-format';
+import { buildPPrChildrenFromSnapshot, emptyParagraphFormatSnapshot, parseParagraphFormat, } from '../document/paragraph-format';
+import { wmlElement } from '../document/wml';
+import { EMPTY_MODELED_PARAGRAPH_PROPERTIES, parseModeledParagraphProperties, serializeModeledParagraphProperties, } from './paragraph-properties';
+import { EMPTY_MODELED_RUN_PROPERTIES, parseModeledRunProperties, serializeModeledRunProperties, } from './run-properties';
+/**
+ * Convert a modeled run-properties bag into a CharacterFormat hydrate snapshot.
+ * Uses serialize → parse so theme fonts, underline, lang, and size units match
+ * the body CF codec.
+ *
+ * @private
+ */
+export function modeledRunPropertiesToCharacterSnapshot(properties) {
+    var rPr = serializeModeledRunProperties(properties);
+    if (rPr === undefined) {
+        return parseCharacterFormat(wmlElement('rPr'));
+    }
+    return parseCharacterFormat(rPr);
+}
+/**
+ * Convert a live CharacterFormat snapshot into a modeled run-properties bag for
+ * resolver merge / theme resolution. Unsupported children stay on the snapshot
+ * (`rPrExtra`) and are not reduced into ModeledRunProperties.
+ *
+ * @private
+ */
+export function characterSnapshotToModeledRunProperties(snapshot) {
+    var children = buildRPrChildrenFromSnapshot(snapshot);
+    if (children.length === 0) {
+        return EMPTY_MODELED_RUN_PROPERTIES;
+    }
+    return parseModeledRunProperties(wmlElement('rPr', { children: children }));
+}
+/**
+ * Convert a modeled paragraph-properties bag into a ParagraphFormat snapshot.
+ *
+ * @private
+ */
+export function modeledParagraphPropertiesToParagraphSnapshot(properties) {
+    var pPr = serializeModeledParagraphProperties(properties);
+    if (pPr === undefined) {
+        return emptyParagraphFormatSnapshot();
+    }
+    return parseParagraphFormat(pPr);
+}
+/**
+ * Convert a live ParagraphFormat snapshot into a modeled paragraph-properties bag.
+ *
+ * @private
+ */
+export function paragraphSnapshotToModeledParagraphProperties(snapshot) {
+    var children = buildPPrChildrenFromSnapshot(snapshot);
+    if (children.length === 0) {
+        return EMPTY_MODELED_PARAGRAPH_PROPERTIES;
+    }
+    return parseModeledParagraphProperties(wmlElement('pPr', { children: children }));
+}
+/**
+ * Parse full CF snapshot from an optional `w:rPr` element (style body).
+ *
+ * @private
+ */
+export function characterSnapshotFromRPr(rPr) {
+    if (rPr === undefined) {
+        return parseCharacterFormat(wmlElement('rPr'));
+    }
+    return parseCharacterFormat(rPr);
+}
+/**
+ * Parse full PF snapshot from an optional `w:pPr` element (style body).
+ * Style-level `w:pPr` must not carry `w:pStyle` / `w:rPr` / `w:sectPr` as
+ * paragraph-owned children — the PF parser already skips those names.
+ *
+ * @private
+ */
+export function paragraphSnapshotFromPPr(pPr) {
+    if (pPr === undefined) {
+        return emptyParagraphFormatSnapshot();
+    }
+    return parseParagraphFormat(pPr);
+}
+/**
+ * Empty modeled run-properties bag (resolver / package defaults).
+ *
+ * @private
+ */
+export function emptyModeledRunProperties() {
+    return EMPTY_MODELED_RUN_PROPERTIES;
+}

package/src/features/styles/style.d.ts

@@ -0,0 +1,84 @@
+import { OpenXmlAttribute, OpenXmlElement } from '../../core/xml/index';
+import { ModeledRunProperties } from './run-properties';
+/**
+ * `ST_StyleType` (Transitional `wml.xsd`): paragraph | character | table | numbering.
+ *
+ * @private
+ */
+export declare type DocxStyleType = 'paragraph' | 'character' | 'table' | 'numbering';
+/**
+ * One `w:style` definition (`CT_Style`).
+ *
+ * Typed getters cover MVP identity, inheritance, and UI flags. Unmodeled children
+ * (`pPr`, table style props, `personal*`, `rsid`, unknown) are retained opaquely and
+ * re-emitted on serialize after the typed preamble (schema sequence for modeled fields;
+ * extras keep relative order).
+ *
+ * @private
+ */
+export declare class DocxStyle {
+    private readonly styleIdValue;
+    private readonly typeValue;
+    private readonly defaultValue;
+    private readonly customStyleValue;
+    private readonly children;
+    private readonly extraAttributes;
+    /**
+     * @private
+     */
+    constructor(styleId: string, type: DocxStyleType | undefined, defaultFlag: boolean | undefined, customStyle: boolean | undefined, children: OpenXmlElement[], extraAttributes?: OpenXmlAttribute[]);
+    /** `w:style/@w:styleId`. */
+    readonly styleId: string;
+    /** `w:style/@w:type` (`ST_StyleType`), when present and recognized. */
+    readonly type: DocxStyleType | undefined;
+    /** `w:style/@w:default`. */
+    readonly default: boolean | undefined;
+    /** `w:style/@w:customStyle`. */
+    readonly customStyle: boolean | undefined;
+    /** `w:name/@w:val`. */
+    readonly name: string | undefined;
+    /** `w:aliases/@w:val`. */
+    readonly aliases: string | undefined;
+    /** `w:basedOn/@w:val`. */
+    readonly basedOn: string | undefined;
+    /** `w:next/@w:val`. */
+    readonly next: string | undefined;
+    /** `w:link/@w:val`. */
+    readonly link: string | undefined;
+    /** `w:uiPriority/@w:val`. */
+    readonly uiPriority: number | undefined;
+    /** `w:autoRedefine` on/off. */
+    readonly autoRedefine: boolean | undefined;
+    /** `w:hidden` on/off. */
+    readonly hidden: boolean | undefined;
+    /** `w:semiHidden` on/off. */
+    readonly semiHidden: boolean | undefined;
+    /** `w:unhideWhenUsed` on/off. */
+    readonly unhideWhenUsed: boolean | undefined;
+    /** `w:qFormat` on/off. */
+    readonly qFormat: boolean | undefined;
+    /** `w:locked` on/off. */
+    readonly locked: boolean | undefined;
+    /**
+     * Modeled `w:rPr` properties on this style (`w:b`, `w:i`, `w:sz`, `w:rFonts`).
+     *
+     * @private
+     */
+    runProperties(): ModeledRunProperties;
+    /**
+     * @private
+     */
+    serialize(): OpenXmlElement;
+}
+/**
+ * Parse a `w:style` element into {@link DocxStyle}. Returns `undefined` when `styleId` is absent.
+ *
+ * @private
+ */
+export declare function parseDocxStyle(element: OpenXmlElement): DocxStyle | undefined;
+/**
+ * Minimal paragraph, character, or table style used by ensure* / materialize.
+ *
+ * @private
+ */
+export declare function createMinimalDocxStyle(styleId: string, type: 'paragraph' | 'character' | 'table'): DocxStyle;

package/src/features/styles/style.js

@@ -0,0 +1,375 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+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 { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, WML, } from '../document/wml';
+import { parseModeledRunProperties } from './run-properties';
+var STYLE_TYPES = new Set(['paragraph', 'character', 'table', 'numbering']);
+/** CT_Style children emitted from typed fields, in schema sequence order before opaque extras. */
+var MODELED_CHILD_NAMES = new Set([
+    'name',
+    'aliases',
+    'basedOn',
+    'next',
+    'link',
+    'autoRedefine',
+    'hidden',
+    'uiPriority',
+    'semiHidden',
+    'unhideWhenUsed',
+    'qFormat',
+    'locked',
+]);
+function wmlAttribute(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === WML || a.namespaceUri === ''); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function parseStyleType(raw) {
+    if (raw !== undefined && STYLE_TYPES.has(raw)) {
+        return raw;
+    }
+    return undefined;
+}
+function parseOnOffAttribute(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === '' || normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function parseDecimalChild(el) {
+    if (el === undefined) {
+        return undefined;
+    }
+    var raw = wValAttribute(el);
+    if (raw === undefined || !/^-?\d+$/.test(raw.trim())) {
+        return undefined;
+    }
+    return parseInt(raw.trim(), 10);
+}
+function firstWmlChild(children, localName) {
+    return children.find(function (child) { return isWml(child, localName); });
+}
+function readStringVal(children, localName) {
+    var el = firstWmlChild(children, localName);
+    if (el === undefined) {
+        return undefined;
+    }
+    return wValAttribute(el);
+}
+function readOnOffChild(children, localName) {
+    var el = firstWmlChild(children, localName);
+    if (el === undefined) {
+        return undefined;
+    }
+    return parseOnOff(el);
+}
+/**
+ * One `w:style` definition (`CT_Style`).
+ *
+ * Typed getters cover MVP identity, inheritance, and UI flags. Unmodeled children
+ * (`pPr`, table style props, `personal*`, `rsid`, unknown) are retained opaquely and
+ * re-emitted on serialize after the typed preamble (schema sequence for modeled fields;
+ * extras keep relative order).
+ *
+ * @private
+ */
+var DocxStyle = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function DocxStyle(styleId, type, defaultFlag, customStyle, children, extraAttributes) {
+        if (extraAttributes === void 0) { extraAttributes = []; }
+        this.styleIdValue = styleId;
+        this.typeValue = type;
+        this.defaultValue = defaultFlag;
+        this.customStyleValue = customStyle;
+        this.children = children;
+        this.extraAttributes = extraAttributes;
+    }
+    Object.defineProperty(DocxStyle.prototype, "styleId", {
+        /** `w:style/@w:styleId`. */
+        get: function () {
+            return this.styleIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "type", {
+        /** `w:style/@w:type` (`ST_StyleType`), when present and recognized. */
+        get: function () {
+            return this.typeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "default", {
+        /** `w:style/@w:default`. */
+        get: function () {
+            return this.defaultValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "customStyle", {
+        /** `w:style/@w:customStyle`. */
+        get: function () {
+            return this.customStyleValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "name", {
+        /** `w:name/@w:val`. */
+        get: function () {
+            return readStringVal(this.children, 'name');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "aliases", {
+        /** `w:aliases/@w:val`. */
+        get: function () {
+            return readStringVal(this.children, 'aliases');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "basedOn", {
+        /** `w:basedOn/@w:val`. */
+        get: function () {
+            return readStringVal(this.children, 'basedOn');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "next", {
+        /** `w:next/@w:val`. */
+        get: function () {
+            return readStringVal(this.children, 'next');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "link", {
+        /** `w:link/@w:val`. */
+        get: function () {
+            return readStringVal(this.children, 'link');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "uiPriority", {
+        /** `w:uiPriority/@w:val`. */
+        get: function () {
+            return parseDecimalChild(firstWmlChild(this.children, 'uiPriority'));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "autoRedefine", {
+        /** `w:autoRedefine` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'autoRedefine');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "hidden", {
+        /** `w:hidden` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'hidden');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "semiHidden", {
+        /** `w:semiHidden` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'semiHidden');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "unhideWhenUsed", {
+        /** `w:unhideWhenUsed` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'unhideWhenUsed');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "qFormat", {
+        /** `w:qFormat` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'qFormat');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocxStyle.prototype, "locked", {
+        /** `w:locked` on/off. */
+        get: function () {
+            return readOnOffChild(this.children, 'locked');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Modeled `w:rPr` properties on this style (`w:b`, `w:i`, `w:sz`, `w:rFonts`).
+     *
+     * @private
+     */
+    DocxStyle.prototype.runProperties = function () {
+        var rPr = firstWmlChild(this.children, 'rPr');
+        return parseModeledRunProperties(rPr);
+    };
+    /**
+     * @private
+     */
+    DocxStyle.prototype.serialize = function () {
+        var e_1, _a;
+        var attributes = [];
+        if (this.typeValue !== undefined) {
+            attributes.push(wmlAttr('type', this.typeValue));
+        }
+        attributes.push(wmlAttr('styleId', this.styleIdValue));
+        if (this.defaultValue !== undefined) {
+            attributes.push(wmlAttr('default', this.defaultValue ? '1' : '0'));
+        }
+        if (this.customStyleValue !== undefined) {
+            attributes.push(wmlAttr('customStyle', this.customStyleValue ? '1' : '0'));
+        }
+        attributes.push.apply(attributes, __spread(this.extraAttributes));
+        var out = [];
+        var nameVal = this.name;
+        out.push(wmlElement('name', { attributes: [wmlAttr('val', nameVal != null ? nameVal : this.styleIdValue)] }));
+        var aliases = this.aliases;
+        if (aliases !== undefined) {
+            out.push(wmlElement('aliases', { attributes: [wmlAttr('val', aliases)] }));
+        }
+        var basedOn = this.basedOn;
+        if (basedOn !== undefined) {
+            out.push(wmlElement('basedOn', { attributes: [wmlAttr('val', basedOn)] }));
+        }
+        var next = this.next;
+        if (next !== undefined) {
+            out.push(wmlElement('next', { attributes: [wmlAttr('val', next)] }));
+        }
+        var link = this.link;
+        if (link !== undefined) {
+            out.push(wmlElement('link', { attributes: [wmlAttr('val', link)] }));
+        }
+        var autoRedefine = this.autoRedefine;
+        if (autoRedefine !== undefined) {
+            out.push(serializeOnOff('autoRedefine', autoRedefine));
+        }
+        var hidden = this.hidden;
+        if (hidden !== undefined) {
+            out.push(serializeOnOff('hidden', hidden));
+        }
+        var uiPriority = this.uiPriority;
+        if (uiPriority !== undefined) {
+            out.push(wmlElement('uiPriority', { attributes: [wmlAttr('val', String(uiPriority))] }));
+        }
+        var semiHidden = this.semiHidden;
+        if (semiHidden !== undefined) {
+            out.push(serializeOnOff('semiHidden', semiHidden));
+        }
+        var unhideWhenUsed = this.unhideWhenUsed;
+        if (unhideWhenUsed !== undefined) {
+            out.push(serializeOnOff('unhideWhenUsed', unhideWhenUsed));
+        }
+        var qFormat = this.qFormat;
+        if (qFormat !== undefined) {
+            out.push(serializeOnOff('qFormat', qFormat));
+        }
+        var locked = this.locked;
+        if (locked !== undefined) {
+            out.push(serializeOnOff('locked', locked));
+        }
+        try {
+            // Preserve non-modeled children (pPr, rPr, tbl*, personal*, rsid, unknown) in order.
+            for (var _b = __values(this.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (isWml(child, child.localName) && MODELED_CHILD_NAMES.has(child.localName)) {
+                    continue;
+                }
+                out.push(child);
+            }
+        }
+        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 wmlElement('style', { attributes: attributes, children: out });
+    };
+    return DocxStyle;
+}());
+export { DocxStyle };
+/**
+ * Parse a `w:style` element into {@link DocxStyle}. Returns `undefined` when `styleId` is absent.
+ *
+ * @private
+ */
+export function parseDocxStyle(element) {
+    if (!isWml(element, 'style')) {
+        return undefined;
+    }
+    var styleId = wmlAttribute(element, 'styleId');
+    if (styleId === undefined || styleId.length === 0) {
+        return undefined;
+    }
+    var type = parseStyleType(wmlAttribute(element, 'type'));
+    var defaultFlag = parseOnOffAttribute(wmlAttribute(element, 'default'));
+    var customStyle = parseOnOffAttribute(wmlAttribute(element, 'customStyle'));
+    var knownAttr = new Set(['styleId', 'type', 'default', 'customStyle']);
+    var extraAttributes = element.attributes.filter(function (a) { return !(knownAttr.has(a.localName) && (a.namespaceUri === WML || a.namespaceUri === '')); });
+    return new DocxStyle(styleId, type, defaultFlag, customStyle, __spread(elementChildren(element)), extraAttributes);
+}
+/**
+ * Minimal paragraph, character, or table style used by ensure* / materialize.
+ *
+ * @private
+ */
+export function createMinimalDocxStyle(styleId, type) {
+    return new DocxStyle(styleId, type, undefined, undefined, [
+        wmlElement('name', { attributes: [wmlAttr('val', styleId)] }),
+    ]);
+}

package/src/features/styles/styles-with-effects.d.ts

@@ -0,0 +1,71 @@
+import { WordDocument } from '../document/document';
+import { FeaturePackagePart } from '../document/feature-package-part';
+/**
+ * @private
+ * `[MS-DOCX]` §2.1.1 stylesWithEffects relationship. */
+export declare const STYLES_WITH_EFFECTS_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/office/2007/relationships/stylesWithEffects";
+/**
+ * @private
+ * `[MS-DOCX]` stylesWithEffects content type (ooxmlsdk StylesWithEffectsPart). */
+export declare const STYLES_WITH_EFFECTS_CONTENT_TYPE = "application/vnd.ms-word.stylesWithEffects+xml";
+/**
+ * @private
+ */
+export declare const STYLES_WITH_EFFECTS_PART_NAME: import("../../core/opc/part-name").PartName;
+/**
+ * In-memory stylesWithEffects part (`word/stylesWithEffects.xml`).
+ *
+ * @private
+ */
+export declare class StylesWithEffectsPart implements FeaturePackagePart {
+    private readonly bytes;
+    private readonly styleIdList;
+    private readonly dirty;
+    /**
+     * @private
+     */
+    constructor(bytes: Uint8Array | undefined, styleIdList: ReadonlyArray<string>, dirty: boolean);
+    /**
+     * Whether the stylesWithEffects part was present in the package.
+     *
+     * @public
+     */
+    present(): boolean;
+    /**
+     * `w:style/@w:styleId` values in document order.
+     *
+     * @public
+     */
+    styleIds(): ReadonlyArray<string>;
+    /**
+     * Count of readable style ids.
+     *
+     * @public
+     */
+    styleCount(): number;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    serialize(): Uint8Array;
+}
+/**
+ * @private
+ * Test hook */
+export declare function resetStylesWithEffectsFeatureForTests(): void;
+/**
+ * @private
+ * Register the stylesWithEffects package-part handler. Idempotent. */
+export declare function registerStylesWithEffectsFeature(): void;
+/**
+ * stylesWithEffects part for a document. Requires {@link registerStylesFeature} or
+ * {@link registerStylesWithEffectsFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the handler was not registered before load.
+ *
+ * @private
+ */
+export declare function stylesWithEffectsFor(document: WordDocument): StylesWithEffectsPart;