@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/document/units.js

@@ -0,0 +1,7 @@
+/**
+ * Legacy units barrel (package-private). Public APIs use plain point numbers.
+ * or `./length`. Multi-unit constructors are package-private.
+ *
+ * @packageDocumentation
+ */
+export { pointToEmus, pointToHalfPoints, pointToTwips, twipsToPoint, emuToPoint, halfPointsToPoint, addPoints, scalePoint, lengthToEmus, lengthToHalfPoints, halfPoints, emus, LengthUnits, Pt, Inches, Cm, Mm, Px, Twips, Emu, add, scale, inchesToPoint, cmToPoint, mmToPoint, pxToPoint } from './length';

package/src/features/document/wml.d.ts

@@ -0,0 +1,16 @@
+import { OpenXmlAttribute, OpenXmlChild, OpenXmlElement } from '../../core/xml/index';
+export declare const WML = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/** True when the URI is Transitional or Strict WordprocessingML. */
+export declare function isWmlNamespace(namespaceUri: string): boolean;
+export declare function isWml(el: OpenXmlElement, localName: string): boolean;
+export declare function elementChildren(el: OpenXmlElement): ReadonlyArray<OpenXmlElement>;
+export declare function textContent(el: OpenXmlElement): string;
+export declare function wmlAttr(localName: string, value: string): OpenXmlAttribute;
+export declare function xmlSpacePreserve(): OpenXmlAttribute;
+export declare function wmlElement(localName: string, options?: {
+    readonly attributes?: ReadonlyArray<OpenXmlAttribute>;
+    readonly children?: ReadonlyArray<OpenXmlChild>;
+    readonly namespaceDeclarations?: OpenXmlElement['namespaceDeclarations'];
+}): OpenXmlElement;
+export declare function wValAttribute(el: OpenXmlElement): string | undefined;
+export declare function xmlSpaceIsPreserve(el: OpenXmlElement): boolean;

package/src/features/document/wml.js

@@ -0,0 +1,67 @@
+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 { WML_STRICT_NAMESPACE, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE } from '../../core/xml/index';
+export var WML = WML_TRANSITIONAL_NAMESPACE;
+/** True when the URI is Transitional or Strict WordprocessingML. */
+export function isWmlNamespace(namespaceUri) {
+    return namespaceUri === WML_TRANSITIONAL_NAMESPACE || namespaceUri === WML_STRICT_NAMESPACE;
+}
+export function isWml(el, localName) {
+    return isWmlNamespace(el.namespaceUri) && el.localName === localName;
+}
+export function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+export function textContent(el) {
+    var e_1, _a;
+    var out = '';
+    try {
+        for (var _b = __values(el.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'text') {
+                out += child.value;
+            }
+        }
+    }
+    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 out;
+}
+export function wmlAttr(localName, value) {
+    return { namespaceUri: WML, localName: localName, prefix: 'w', value: value };
+}
+export function xmlSpacePreserve() {
+    return { namespaceUri: XML_NAMESPACE, localName: 'space', prefix: 'xml', value: 'preserve' };
+}
+export function wmlElement(localName, options) {
+    var __ts33_0, __ts33_1, __ts33_2;
+    return {
+        kind: 'element',
+        namespaceUri: WML,
+        localName: localName,
+        prefix: 'w',
+        attributes: ((__ts33_0 = options == null ? undefined : options.attributes), __ts33_0 != null ? __ts33_0 : []),
+        namespaceDeclarations: ((__ts33_1 = options == null ? undefined : options.namespaceDeclarations), __ts33_1 != null ? __ts33_1 : []),
+        children: ((__ts33_2 = options == null ? undefined : options.children), __ts33_2 != null ? __ts33_2 : []),
+    };
+}
+export function wValAttribute(el) {
+    var found = el.attributes.find(function (a) { return a.localName === 'val' && (isWmlNamespace(a.namespaceUri) || a.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+export function xmlSpaceIsPreserve(el) {
+    return el.attributes.some(function (a) { return a.localName === 'space' && a.namespaceUri === XML_NAMESPACE && a.value === 'preserve'; });
+}

package/src/features/drawing/authoring.d.ts

@@ -0,0 +1,27 @@
+import { Paragraph } from '../document/paragraph';
+import { AutoShapeType } from './shape-types';
+import { GroupOptions } from './types';
+import { GroupShape, Shape } from './drawing-shape';
+/**
+ * Append a preset-geometry drawing shape as a dual MC run leaf (Policy B).
+ *
+ * Defaults follow Shape.md section 2 (anchor, wrap none, side distances =
+ * package anchor default, default solid fill White, default solid black 1 pt
+ * outline, no modeled text box until text body is accessed).
+ *
+ * @throws DocxError `content/invalid-shape` when geometry or size is invalid.
+ *
+ * @private
+ */
+export declare function appendShapeToParagraph(paragraph: Paragraph, autoShapeType: AutoShapeType, width: number, height: number): Shape;
+/**
+ * Append an empty wordprocessing group as dual MC run leaf (Choice `wpg` +
+ * Fallback VML). Nested children are authored via {@link GroupShape.appendShape}
+ * on the returned group. Default placement is `wp:anchor`.
+ *
+ * @throws DocxError `content/invalid-shape` when size is invalid.
+ * @throws RangeError when wrap/position enums are not known schema tokens.
+ *
+ * @private
+ */
+export declare function appendGroupToParagraph(paragraph: Paragraph, options: GroupOptions): GroupShape;

package/src/features/drawing/authoring.js

@@ -0,0 +1,271 @@
+/**
+ * Drawing authoring APIs (`appendShape` / `appendGroup`).
+ *
+ * @private
+ */
+import { pointToEmus, pointToCoordinateEmus, emuToPoint } from '../document/length';
+import { DocxError } from '../../core/errors/docx-error';
+import { assertEnumMember, HORIZONTAL_ALIGNMENT_SET, HORIZONTAL_ORIGIN_SET, TEXT_WRAPPING_STYLE_SET, TextWrappingStyle, VERTICAL_ALIGNMENT_SET, VERTICAL_ORIGIN_SET } from '../images/layout-types';
+import { encodeAuthoredDrawingShape, encodeAuthoredGroup } from './host-codec';
+import { isPresetAutoShapeType } from './shape-types';
+import { ANCHOR_DEFAULT_SIDE_DIST_EMU, DRAWING } from './types';
+import { GroupShape, Shape } from './drawing-shape';
+import { drawingShapeInit, encodeDrawingShapeInput, encodeGroupInput, modeledFillForEncode, modeledLineForEncode } from './encode-builders';
+import { defaultAuthoredShapeFill } from './fill-format';
+import { defaultAuthoredShapeLine } from './line-format';
+import { allocateDocPrId } from './parse-register';
+var ANCHOR_DEFAULT_SIDE_DIST_POINTS = emuToPoint(ANCHOR_DEFAULT_SIDE_DIST_EMU);
+/**
+ * Append a preset-geometry drawing shape as a dual MC run leaf (Policy B).
+ *
+ * Defaults follow Shape.md section 2 (anchor, wrap none, side distances =
+ * package anchor default, default solid fill White, default solid black 1 pt
+ * outline, no modeled text box until text body is accessed).
+ *
+ * @throws DocxError `content/invalid-shape` when geometry or size is invalid.
+ *
+ * @private
+ */
+export function appendShapeToParagraph(paragraph, autoShapeType, width, height) {
+    if (!isPresetAutoShapeType(autoShapeType)) {
+        throw new DocxError('content/invalid-shape', "Invalid autoShapeType \"" + String(autoShapeType) + "\"; expected a preset AutoShapeType token");
+    }
+    var widthEmu;
+    var heightEmu;
+    try {
+        widthEmu = pointToEmus(width);
+        heightEmu = pointToEmus(height);
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            throw new DocxError('content/invalid-shape', 'Shape width and height must be positive point values', { cause: error });
+        }
+        throw error;
+    }
+    if (!(widthEmu > 0) || !(heightEmu > 0)) {
+        throw new DocxError('content/invalid-shape', 'Shape width and height must be positive point values');
+    }
+    var placement = 'anchor';
+    var wrapping = TextWrappingStyle.None;
+    var docPrId = allocateDocPrId(paragraph);
+    var name = 'Shape';
+    var rotation = 0;
+    var lockAspectRatio = true;
+    var flipHorizontal = false;
+    var flipVertical = false;
+    var distanceTop = 0;
+    var distanceBottom = 0;
+    var distanceLeft = ANCHOR_DEFAULT_SIDE_DIST_POINTS;
+    var distanceRight = ANCHOR_DEFAULT_SIDE_DIST_POINTS;
+    var behindDocument = false;
+    var lockAnchor = false;
+    var allowOverlap = true;
+    var layoutInCell = true;
+    var defaultFill = defaultAuthoredShapeFill();
+    var defaultLine = defaultAuthoredShapeLine();
+    var encodeFill = modeledFillForEncode(defaultFill);
+    var encodeLine = modeledLineForEncode(defaultLine);
+    var residual = encodeAuthoredDrawingShape(encodeDrawingShapeInput({
+        placement: placement,
+        widthEmu: widthEmu,
+        heightEmu: heightEmu,
+        presetGeometry: autoShapeType,
+        docPrId: docPrId,
+        name: name,
+        title: undefined,
+        description: undefined,
+        rotation: rotation,
+        flipHorizontal: flipHorizontal,
+        flipVertical: flipVertical,
+        lockAspectRatio: lockAspectRatio,
+        wrapping: wrapping,
+        distanceTopEmu: pointToCoordinateEmus(distanceTop),
+        distanceBottomEmu: pointToCoordinateEmus(distanceBottom),
+        distanceLeftEmu: ANCHOR_DEFAULT_SIDE_DIST_EMU,
+        distanceRightEmu: ANCHOR_DEFAULT_SIDE_DIST_EMU,
+        behindDocument: behindDocument,
+        lockAnchor: lockAnchor,
+        allowOverlap: allowOverlap,
+        layoutInCell: layoutInCell,
+        layoutDirty: true,
+        txbxContent: undefined,
+        bodyPr: undefined,
+        fill: encodeFill,
+        line: encodeLine,
+    }));
+    var shape = new Shape(drawingShapeInit({
+        encoding: 'drawingml',
+        residual: residual,
+        dirty: 'structure',
+        name: name,
+        title: undefined,
+        description: undefined,
+        docPrId: docPrId,
+        placement: placement,
+        width: width,
+        height: height,
+        presetGeometry: autoShapeType,
+        rotation: rotation,
+        lockAspectRatio: lockAspectRatio,
+        flipHorizontal: flipHorizontal,
+        flipVertical: flipVertical,
+        wrapping: wrapping,
+        distanceTop: distanceTop,
+        distanceBottom: distanceBottom,
+        distanceLeft: distanceLeft,
+        distanceRight: distanceRight,
+        behindDocument: behindDocument,
+        lockAnchor: lockAnchor,
+        allowOverlap: allowOverlap,
+        layoutInCell: layoutInCell,
+        txbxContent: undefined,
+        bodyPrElement: undefined,
+        fill: defaultFill,
+        line: defaultLine,
+    }));
+    paragraph.appendFeatureRunItem(DRAWING, shape);
+    shape.bindAnchoringParagraph(paragraph);
+    return shape;
+}
+/**
+ * Append an empty wordprocessing group as dual MC run leaf (Choice `wpg` +
+ * Fallback VML). Nested children are authored via {@link GroupShape.appendShape}
+ * on the returned group. Default placement is `wp:anchor`.
+ *
+ * @throws DocxError `content/invalid-shape` when size is invalid.
+ * @throws RangeError when wrap/position enums are not known schema tokens.
+ *
+ * @private
+ */
+export function appendGroupToParagraph(paragraph, options) {
+    var widthEmu;
+    var heightEmu;
+    try {
+        widthEmu = pointToEmus(options.width);
+        heightEmu = pointToEmus(options.height);
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            throw new DocxError('content/invalid-shape', 'Group width and height must be positive point values', { cause: error });
+        }
+        throw error;
+    }
+    if (!(widthEmu > 0) || !(heightEmu > 0)) {
+        throw new DocxError('content/invalid-shape', 'Group width and height must be positive point values');
+    }
+    var placementRaw = options.placement != null ? options.placement : 'anchor';
+    if (placementRaw !== 'inline' && placementRaw !== 'anchor') {
+        throw new DocxError('content/invalid-shape', "Invalid placement \"" + placementRaw + "\"; expected 'inline' or 'anchor'");
+    }
+    var placement = placementRaw;
+    var wrapping = options.wrappingStyle;
+    if (wrapping !== undefined) {
+        assertEnumMember('wrappingStyle', wrapping, TEXT_WRAPPING_STYLE_SET);
+        placement = wrapping === TextWrappingStyle.Inline ? 'inline' : 'anchor';
+    }
+    else {
+        wrapping = placement === 'inline' ? TextWrappingStyle.Inline : TextWrappingStyle.None;
+    }
+    var docPrId = allocateDocPrId(paragraph);
+    var name = options.name != null ? options.name : 'Group';
+    var rotation = options.rotation != null ? options.rotation : 0;
+    if (!Number.isFinite(rotation)) {
+        throw new DocxError('content/invalid-shape', 'Group rotation must be a finite number of degrees');
+    }
+    var lockAspectRatio = options.lockAspectRatio != null ? options.lockAspectRatio : true;
+    var flipHorizontal = options.flipHorizontal != null ? options.flipHorizontal : false;
+    var flipVertical = options.flipVertical != null ? options.flipVertical : false;
+    var distanceTopEmu = options.distanceTop !== undefined ? pointToCoordinateEmus(options.distanceTop) : undefined;
+    var distanceBottomEmu = options.distanceBottom !== undefined ? pointToCoordinateEmus(options.distanceBottom) : undefined;
+    var distanceLeftEmu = options.distanceLeft !== undefined ? pointToCoordinateEmus(options.distanceLeft) : undefined;
+    var distanceRightEmu = options.distanceRight !== undefined ? pointToCoordinateEmus(options.distanceRight) : undefined;
+    var behindDocument = options.behindDocument;
+    var horizontalOrigin = options.horizontalOrigin;
+    var verticalOrigin = options.verticalOrigin;
+    var horizontalPositionEmu = options.horizontalPosition !== undefined ? pointToCoordinateEmus(options.horizontalPosition) : undefined;
+    var verticalPositionEmu = options.verticalPosition !== undefined ? pointToCoordinateEmus(options.verticalPosition) : undefined;
+    var horizontalAlignment = options.horizontalAlignment;
+    var verticalAlignment = options.verticalAlignment;
+    if (horizontalAlignment !== undefined) {
+        assertEnumMember('horizontalAlignment', horizontalAlignment, HORIZONTAL_ALIGNMENT_SET);
+    }
+    if (verticalAlignment !== undefined) {
+        assertEnumMember('verticalAlignment', verticalAlignment, VERTICAL_ALIGNMENT_SET);
+    }
+    if (horizontalOrigin !== undefined) {
+        assertEnumMember('horizontalOrigin', horizontalOrigin, HORIZONTAL_ORIGIN_SET);
+    }
+    if (verticalOrigin !== undefined) {
+        assertEnumMember('verticalOrigin', verticalOrigin, VERTICAL_ORIGIN_SET);
+    }
+    var horizontalAlignmentFinal = options.horizontalPosition !== undefined ? undefined : horizontalAlignment;
+    var verticalAlignmentFinal = options.verticalPosition !== undefined ? undefined : verticalAlignment;
+    var lockAnchor = options.lockAnchor;
+    var allowOverlap = options.allowOverlap;
+    var layoutInCell = options.layoutInCell;
+    var residual = encodeAuthoredGroup(encodeGroupInput({
+        placement: placement,
+        widthEmu: widthEmu,
+        heightEmu: heightEmu,
+        docPrId: docPrId,
+        name: name,
+        title: options.title,
+        description: options.description,
+        rotation: rotation,
+        flipHorizontal: flipHorizontal,
+        flipVertical: flipVertical,
+        lockAspectRatio: lockAspectRatio,
+        wrapping: wrapping,
+        distanceTopEmu: distanceTopEmu,
+        distanceBottomEmu: distanceBottomEmu,
+        distanceLeftEmu: distanceLeftEmu,
+        distanceRightEmu: distanceRightEmu,
+        behindDocument: behindDocument,
+        horizontalOrigin: horizontalOrigin,
+        verticalOrigin: verticalOrigin,
+        horizontalPositionEmu: horizontalPositionEmu,
+        verticalPositionEmu: verticalPositionEmu,
+        horizontalAlignment: horizontalAlignmentFinal,
+        verticalAlignment: verticalAlignmentFinal,
+        lockAnchor: lockAnchor,
+        allowOverlap: allowOverlap,
+        layoutInCell: layoutInCell,
+        layoutDirty: true,
+        children: [],
+    }));
+    var shape = new GroupShape(drawingShapeInit({
+        encoding: 'drawingml',
+        residual: residual,
+        dirty: 'structure',
+        name: name,
+        title: options.title,
+        description: options.description,
+        docPrId: docPrId,
+        placement: placement,
+        width: options.width,
+        height: options.height,
+        rotation: rotation,
+        lockAspectRatio: lockAspectRatio,
+        flipHorizontal: flipHorizontal,
+        flipVertical: flipVertical,
+        wrapping: wrapping,
+        distanceTop: options.distanceTop,
+        distanceBottom: options.distanceBottom,
+        distanceLeft: options.distanceLeft,
+        distanceRight: options.distanceRight,
+        behindDocument: behindDocument,
+        horizontalOrigin: horizontalOrigin,
+        verticalOrigin: verticalOrigin,
+        horizontalPosition: options.horizontalPosition,
+        verticalPosition: options.verticalPosition,
+        horizontalAlignment: horizontalAlignmentFinal,
+        verticalAlignment: verticalAlignmentFinal,
+        lockAnchor: lockAnchor,
+        allowOverlap: allowOverlap,
+        layoutInCell: layoutInCell,
+        children: [],
+    }));
+    paragraph.appendFeatureRunItem(DRAWING, shape);
+    shape.bindAnchoringParagraph(paragraph);
+    return shape;
+}

package/src/features/drawing/body-pr.d.ts

@@ -0,0 +1,271 @@
+/**
+ * `wps:bodyPr` text-body properties codec (TASK-8049).
+ *
+ * Schema cites (transitional `dml-main.xsd` + `dml-wordprocessingDrawing.xsd`):
+ * - `CT_TextBodyProperties` attributes: `rot`, `spcFirstLastPara`,
+ *   `vertOverflow` (`ST_TextVertOverflowType`), `horzOverflow`
+ *   (`ST_TextHorzOverflowType`), `vert` (`ST_TextVerticalType`), `wrap`
+ *   (`ST_TextWrappingType` = `none|square` only), `lIns`/`tIns`/`rIns`/`bIns`
+ *   (`ST_Coordinate32` EMU), `numCol`, `spcCol`, `rtlCol`, `fromWordArt`,
+ *   `anchor` (`ST_TextAnchoringType`), `anchorCtr`, `forceAA`, `upright`
+ *   (default false), `compatLnSpc`
+ * - Sequence: `prstTxWarp?`, `EG_TextAutofit?` (`a:noAutofit` |
+ *   `a:normAutofit` | `a:spAutoFit`), `scene3d?`, `EG_Text3D?`, `extLst?`
+ * - `CT_TextNormalAutofit`: `@fontScale` (`ST_TextFontScalePercent` 1000…100000,
+ *   default 100%), `@lnSpcReduction` (default 0%)
+ * - Wire element: **`wps:bodyPr`** (type `a:CT_TextBodyProperties`); autofit
+ *   children use the DrawingML `a:` namespace
+ * - `CT_WordprocessingShape` (dml-wordprocessingDrawing): after `style?` /
+ *   `extLst?` / `txbx|linkedTxbx?`, **`bodyPr` minOccurs=1**
+ *
+ * Unknown attrs and residual children (`prstTxWarp`, `scene3d`, Text3D,
+ * `extLst`) stay residual — never invent OOXML.
+ *
+ * @packageDocumentation
+ */
+import { Emus } from '../document/length';
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * DrawingML text anchoring (`ST_TextAnchoringType`).
+ *
+ * @private
+ */
+export declare const TEXT_ANCHORING_VALUES: string[];
+/**
+ * DrawingML text anchoring token.
+ *
+ * @private
+ */
+export declare type TextAnchoring = (typeof TEXT_ANCHORING_VALUES)[number];
+/**
+ * DrawingML vertical text overflow (`ST_TextVertOverflowType`).
+ *
+ * @private
+ */
+export declare const TEXT_VERT_OVERFLOW_VALUES: string[];
+/**
+ * DrawingML vertical text overflow token.
+ *
+ * @private
+ */
+export declare type TextVertOverflow = (typeof TEXT_VERT_OVERFLOW_VALUES)[number];
+/**
+ * DrawingML horizontal text overflow (`ST_TextHorzOverflowType`).
+ *
+ * @private
+ */
+export declare const TEXT_HORZ_OVERFLOW_VALUES: string[];
+/**
+ * DrawingML horizontal text overflow token.
+ *
+ * @private
+ */
+export declare type TextHorzOverflow = (typeof TEXT_HORZ_OVERFLOW_VALUES)[number];
+/**
+ * DrawingML text vertical type (`ST_TextVerticalType`).
+ *
+ * @private
+ */
+export declare const TEXT_VERTICAL_TYPE_VALUES: string[];
+/**
+ * DrawingML text vertical type token.
+ *
+ * @private
+ */
+export declare type TextVerticalType = (typeof TEXT_VERTICAL_TYPE_VALUES)[number];
+/**
+ * DrawingML text wrapping inside the shape (`ST_TextWrappingType`).
+ * Schema allows **`none` | `square` only**.
+ *
+ * @private
+ */
+export declare const TEXT_BODY_WRAP_VALUES: string[];
+/**
+ * DrawingML text body wrap token (`none` | `square`).
+ *
+ * @private
+ */
+export declare type TextBodyWrap = (typeof TEXT_BODY_WRAP_VALUES)[number];
+/**
+ * Autofit choice (`EG_TextAutofit`): `a:noAutofit` | `a:normAutofit` | `a:spAutoFit`.
+ *
+ * @private
+ */
+export declare type TextAutoFit = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'normal';
+    readonly fontScale?: number;
+    readonly lineSpaceReduction?: number;
+} | {
+    readonly kind: 'shape';
+};
+/**
+ * Whether `value` is a schema `ST_TextAnchoringType` token.
+ *
+ * @private
+ */
+export declare function isTextAnchoring(value: string): value is TextAnchoring;
+/**
+ * Whether `value` is a schema `ST_TextVertOverflowType` token.
+ *
+ * @private
+ */
+export declare function isTextVertOverflow(value: string): value is TextVertOverflow;
+/**
+ * Whether `value` is a schema `ST_TextHorzOverflowType` token.
+ *
+ * @private
+ */
+export declare function isTextHorzOverflow(value: string): value is TextHorzOverflow;
+/**
+ * Whether `value` is a schema `ST_TextVerticalType` token.
+ *
+ * @private
+ */
+export declare function isTextVerticalType(value: string): value is TextVerticalType;
+/**
+ * Whether `value` is a schema `ST_TextWrappingType` token (`none`|`square`).
+ *
+ * @private
+ */
+export declare function isTextBodyWrap(value: string): value is TextBodyWrap;
+/**
+ * Text-body insets from `wps:bodyPr` (`lIns`/`tIns`/`rIns`/`bIns`,
+ * `ST_Coordinate32`, ≥0).
+ *
+ * @private
+ */
+export interface BodyInsets {
+    readonly left?: number | undefined;
+    readonly top?: number | undefined;
+    readonly right?: number | undefined;
+    readonly bottom?: number | undefined;
+}
+/**
+ * @private
+ * Typed MVP state read from `wps:bodyPr`.
+ * Residual `prstTxWarp` / 3D / extLst / unknown attrs are flagged, not modeled.
+ */
+export interface BodyPropertiesState {
+    readonly verticalAnchor: TextAnchoring | undefined;
+    readonly anchorCenter: boolean | undefined;
+    readonly textDirection: TextVerticalType | undefined;
+    readonly textWrapInside: TextBodyWrap | undefined;
+    readonly verticalOverflow: TextVertOverflow | undefined;
+    readonly horizontalOverflow: TextHorzOverflow | undefined;
+    readonly fromWordArt: boolean | undefined;
+    readonly insets: BodyInsets | undefined;
+    readonly autoFit: TextAutoFit | undefined;
+    /** `a:prstTxWarp` present — residual WordArt warp path. */
+    readonly hasPresetTextWarp: boolean;
+    /** Unknown residual children (scene3d / Text3D / extLst) or unmodeled attrs. */
+    readonly residual: boolean;
+}
+/**
+ * Shallow child lookup under `root` (direct element children only).
+ *
+ * @private
+ */
+export declare function findBodyPrChild(root: OpenXmlElement, namespaceUri: string, localName: string): OpenXmlElement | undefined;
+/**
+ * Locate `wps:bodyPr` under a residual dual-AC drawing host.
+ *
+ * @private
+ */
+export declare function findBodyPrElement(residual: OpenXmlElement): OpenXmlElement | undefined;
+/**
+ * Locate `wps:txbx` under a residual dual-AC drawing host.
+ *
+ * @private
+ */
+export declare function findTxbxElement(residual: OpenXmlElement): OpenXmlElement | undefined;
+/**
+ * Locate `w:txbxContent` under a residual host (WML namespace, local `txbxContent`).
+ *
+ * @private
+ */
+export declare function findTxbxContentElement(residual: OpenXmlElement): OpenXmlElement | undefined;
+/**
+ * Read `wps:bodyPr` MVP state from residual DrawingML host.
+ *
+ * Residual hosts are dual MC AlternateContent trees, so `wps:bodyPr` is
+ * located with a deep walk. Children of the found bodyPr stay shallow.
+ *
+ * Cites: `CT_TextBodyProperties` + `EG_TextAutofit` (dml-main.xsd);
+ * `CT_WordprocessingShape/bodyPr` (dml-wordprocessingDrawing.xsd).
+ *
+ * @private
+ */
+export declare function readBodyPropertiesState(residual: OpenXmlElement): BodyPropertiesState;
+/**
+ * Build `wps:bodyPr` from the modeled MVP subset.
+ *
+ * Always emits the element (schema requires bodyPr on `wps:wsp`). When no
+ * modeled fields are set, emits empty `<wps:bodyPr/>`.
+ *
+ * Autofit children use the DrawingML `a:` namespace. Residual warp/3d/extLst
+ * are not re-emitted on the full structure rebuild path.
+ *
+ * @private
+ */
+export declare function buildBodyPrElement(state: {
+    readonly verticalAnchor?: TextAnchoring | undefined;
+    readonly anchorCenter?: boolean | undefined;
+    readonly textDirection?: TextVerticalType | undefined;
+    readonly textWrapInside?: TextBodyWrap | undefined;
+    readonly verticalOverflow?: TextVertOverflow | undefined;
+    readonly horizontalOverflow?: TextHorzOverflow | undefined;
+    readonly fromWordArt?: boolean | undefined;
+    readonly insets?: BodyInsets | undefined;
+    readonly autoFit?: TextAutoFit | undefined;
+}): OpenXmlElement;
+/**
+ * Whether any modeled bodyPr field is present (used by encode path to decide
+ * empty vs populated bodyPr emission — empty is still required on wsp).
+ *
+ * @private
+ */
+export declare function hasModeledBodyPrFields(state: {
+    readonly verticalAnchor?: TextAnchoring | undefined;
+    readonly anchorCenter?: boolean | undefined;
+    readonly textDirection?: TextVerticalType | undefined;
+    readonly textWrapInside?: TextBodyWrap | undefined;
+    readonly verticalOverflow?: TextVertOverflow | undefined;
+    readonly horizontalOverflow?: TextHorzOverflow | undefined;
+    readonly fromWordArt?: boolean | undefined;
+    readonly insets?: BodyInsets | undefined;
+    readonly autoFit?: TextAutoFit | undefined;
+}): boolean;
+/**
+ * @private
+ * Re-export Emus brand helper for encode callers that store inset EMUs. */
+export declare type BodyInsetEmus = Emus;
+/**
+ * Public text direction inside a shape text frame (`wps:bodyPr/@vert`).
+ * @public
+ */
+export declare const TextDirection: {
+    Horizontal: "horz";
+    Vertical: "vert";
+    Vertical270: "vert270";
+    WordArtVertical: "wordArtVert";
+    EastAsianVertical: "eaVert";
+    MongolianVertical: "mongolianVert";
+    WordArtVerticalRtl: "wordArtVertRtl";
+};
+/** @public */
+export declare type TextDirection = (typeof TextDirection)[keyof typeof TextDirection];
+/**
+ * Public vertical alignment of text inside a shape text frame (`wps:bodyPr/@anchor`).
+ * @public
+ */
+export declare const TextVerticalAlignment: {
+    Top: "t";
+    Center: "ctr";
+    Bottom: "b";
+    Justified: "just";
+    Distributed: "dist";
+};
+/** @public */
+export declare type TextVerticalAlignment = (typeof TextVerticalAlignment)[keyof typeof TextVerticalAlignment];