@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/drawing/sp-pr.js

@@ -0,0 +1,610 @@
+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 { objectValues } from '../../core/compat/object-compat';
+import { DocxError } from '../../core/errors/docx-error';
+import { isStShapeType } from './shape-types';
+import { A_NS, WPS_NS } from './host-codec';
+/**
+ * DrawingML line preset dash (`ST_PresetLineDashVal` / `a:prstDash/@val`).
+ *
+ * Members are schema wire tokens. Prefer these constants over raw strings.
+ *
+ * @public
+ */
+/**
+ * DrawingML line dash style for public LineFormat APIs.
+ *
+ * Preset members match `ST_PresetLineDashVal` / `a:prstDash/@val` wire tokens.
+ * `Unknown` is model-only (custom dash, residual, or unrecognized). Never
+ * serialize `Unknown` as `a:prstDash/@val`.
+ *
+ * @public
+ */
+export var LineDashing = {
+    Solid: 'solid',
+    Dot: 'dot',
+    Dash: 'dash',
+    LargeDash: 'lgDash',
+    DashDot: 'dashDot',
+    LargeDashDot: 'lgDashDot',
+    LargeDashDotDot: 'lgDashDotDot',
+    SystemDash: 'sysDash',
+    SystemDot: 'sysDot',
+    SystemDashDot: 'sysDashDot',
+    SystemDashDotDot: 'sysDashDotDot',
+    Unknown: 'unknown',
+};
+/**
+ * Closed set of public LineDashing values.
+ * @public
+ */
+export var LINE_DASHING_VALUES = objectValues(LineDashing);
+/** Wire tokens for `a:prstDash/@val` (excludes model-only Unknown). @private */
+var PRESET_LINE_DASH_WIRE_VALUES = LINE_DASHING_VALUES.filter(function (v) {
+    return v !== LineDashing.Unknown;
+});
+var LINE_DASHING_SET = new Set(LINE_DASHING_VALUES);
+var PRESET_LINE_DASH_WIRE_SET = new Set(PRESET_LINE_DASH_WIRE_VALUES);
+/**
+ * Whether `value` is a public LineDashing token (including Unknown).
+ * @public
+ */
+export function isLineDashing(value) {
+    return LINE_DASHING_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_PresetLineDashVal` wire token.
+ * @private
+ */
+function isPresetLineDashWire(value) {
+    return PRESET_LINE_DASH_WIRE_SET.has(value);
+}
+/**
+ * Specifies how open line ends are capped (`ST_LineCap` / `a:ln/@cap`).
+ *
+ * Prefer these constants over raw strings when setting line cap style.
+ *
+ * @public
+ */
+export var LineCap = {
+    /**
+     * Round cap at each open end of the stroke.
+     * @public
+     */
+    Round: 'rnd',
+    /**
+     * Square cap extending half the line width past each open end.
+     * @public
+     */
+    Square: 'sq',
+    /**
+     * Flat cap that ends exactly at the line endpoint.
+     * @public
+     */
+    Flat: 'flat',
+};
+/**
+ * Closed set of `ST_LineCap` wire tokens.
+ * @public
+ */
+export var LINE_CAP_VALUES = objectValues(LineCap);
+/**
+ * Specifies the arrowhead shape drawn at the beginning or end of a line
+ * (`ST_LineEndType` / `a:headEnd|a:tailEnd/@type`).
+ *
+ * Prefer these constants over raw strings when setting line end type.
+ *
+ * @public
+ */
+export var LineEndType = {
+    /**
+     * No arrowhead at the line end.
+     * @public
+     */
+    None: 'none',
+    /**
+     * Filled triangular arrowhead.
+     * @public
+     */
+    Triangle: 'triangle',
+    /**
+     * Stealth (indented) arrowhead.
+     * @public
+     */
+    Stealth: 'stealth',
+    /**
+     * Diamond-shaped line end marker.
+     * @public
+     */
+    Diamond: 'diamond',
+    /**
+     * Oval line end marker.
+     * @public
+     */
+    Oval: 'oval',
+    /**
+     * Open arrowhead.
+     * @public
+     */
+    Arrow: 'arrow',
+};
+/**
+ * Closed set of `ST_LineEndType` wire tokens.
+ * @public
+ */
+export var LINE_END_TYPE_VALUES = objectValues(LineEndType);
+/**
+ * DrawingML arrow end size tokens (`ST_LineEndWidth` / `ST_LineEndLength`).
+ * @public
+ */
+export var LINE_END_SIZE_VALUES = ['sm', 'med', 'lg'];
+/**
+ * Shape line fill kind discriminant (`EG_LineFillProperties` MVP).
+ *
+ * Members are model tokens (not a single XSD enum). Prefer these constants
+ * over raw strings when authoring {@link ShapeLine}.
+ *
+ * @public
+ */
+export var ShapeLineKind = {
+    Solid: 'solid',
+    None: 'none',
+    Theme: 'theme',
+    Unknown: 'unknown',
+};
+var LINE_CAP_SET = new Set(LINE_CAP_VALUES);
+var LINE_END_TYPE_SET = new Set(LINE_END_TYPE_VALUES);
+var LINE_END_SIZE_SET = new Set(LINE_END_SIZE_VALUES);
+/** Schema max for `ST_LineWidth` (`ST_Coordinate32Unqualified` ≤ 20116800). */
+var LINE_WIDTH_MAX_EMU = 20116800;
+/**
+ * Whether `value` is a schema `ST_LineCap` token.
+ *
+ * @private
+ */
+export function isLineCap(value) {
+    return LINE_CAP_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_LineEndType` token.
+ *
+ * @private
+ */
+export function isLineEndType(value) {
+    return LINE_END_TYPE_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_LineEndWidth`/`ST_LineEndLength` token.
+ *
+ * @private
+ */
+export function isLineEndSize(value) {
+    return LINE_END_SIZE_SET.has(value);
+}
+function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function isElement(el, namespaceUri, localName) {
+    return el.namespaceUri === namespaceUri && el.localName === localName;
+}
+/**
+ * Shallow child lookup under `root` (direct element children only).
+ * Use for children of a known `wps:spPr` or `a:ln` parent.
+ *
+ * @private
+ */
+export function findSpPrElement(root, namespaceUri, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isElement(child, namespaceUri, localName)) {
+                return 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 undefined;
+}
+/**
+ * Deep first-match walker under `root` (including `root` itself).
+ * Local to this module so residual dual-AC hosts can be searched without a
+ * circular import on host-codec `findFirstElement`.
+ */
+function findDeepElement(root, namespaceUri, localName) {
+    var e_2, _a;
+    if (isElement(root, namespaceUri, localName)) {
+        return root;
+    }
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var found = findDeepElement(child, namespaceUri, localName);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+/** s:ST_HexColorRGB — six hex digits. */
+var HEX6 = /^[0-9a-fA-F]{6}$/;
+/**
+ * Read the sRGB color from a `CT_SolidColorFillProperties` (or `a:ln` fill).
+ * Only `a:srgbClr` is typed (GO MVP); other `EG_ColorChoice` members read as
+ * theme-ish `undefined` so the typed surface never invents values.
+ */
+export function solidFillSrgb(parent) {
+    var __ts33_0;
+    var srgb = findSpPrElement(parent, A_NS, 'srgbClr');
+    if (srgb === undefined) {
+        return undefined;
+    }
+    var val = ((__ts33_0 = srgb.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'val'; })), __ts33_0 == null ? undefined : __ts33_0.value);
+    return val !== undefined && HEX6.test(val) ? val.toLowerCase() : undefined;
+}
+/**
+ * Read DrawingML `a:alpha/@val` under a solid-fill parent (0…100000 opacity units).
+ * @private
+ */
+export function solidFillAlpha(parent) {
+    var __ts33_a;
+    var srgb = findSpPrElement(parent, A_NS, 'srgbClr');
+    if (srgb === undefined) {
+        return undefined;
+    }
+    var alpha = findSpPrElement(srgb, A_NS, 'alpha');
+    if (alpha === undefined) {
+        return undefined;
+    }
+    var raw = ((__ts33_a = alpha.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'val'; })), __ts33_a == null ? undefined : __ts33_a.value);
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    var n = Number.parseInt(raw, 10);
+    return n >= 0 && n <= 100000 ? n : undefined;
+}
+/**
+ * Convert public transparency percent (0–100) to DrawingML alpha (0–100000 opacity).
+ * @private
+ */
+export function transparencyToAlpha(transparency) {
+    var t = Math.max(0, Math.min(100, transparency));
+    return Math.round((100 - t) * 1000);
+}
+/**
+ * Convert DrawingML alpha (0–100000 opacity) to public transparency percent (0–100).
+ * @private
+ */
+export function alphaToTransparency(alpha) {
+    if (alpha === undefined) {
+        return 0;
+    }
+    var a = Math.max(0, Math.min(100000, alpha));
+    return Math.round(100 - a / 1000);
+}
+/**
+ * Read `wps:spPr` geometry/fill/line MVP state.
+ *
+ * Residual hosts are dual MC AlternateContent trees (`w:drawing` /
+ * `mc:AlternateContent` / `mc:Choice` / `wp:anchor` / `a:graphic` /
+ * `wps:wsp`), so `wps:spPr` and sibling `wps:style` are located with a deep
+ * walk. Children of the found `spPr` stay shallow.
+ *
+ * Cites: `CT_ShapeProperties` sequence + `EG_FillProperties`/`CT_LineProperties`
+ * (dml-main.xsd); `wps:style` residual theme formatting (CT_ShapeStyle).
+ */
+export function readShapePropertiesState(residual) {
+    var __ts33_1;
+    var spPr = findDeepElement(residual, WPS_NS, 'spPr');
+    if (spPr === undefined) {
+        return {
+            presetGeometry: undefined,
+            useCustomGeometry: false,
+            fill: undefined,
+            line: undefined,
+            hasThemeStyle: false,
+        };
+    }
+    var prstGeom = findSpPrElement(spPr, A_NS, 'prstGeom');
+    var custGeom = findSpPrElement(spPr, A_NS, 'custGeom');
+    var prstRaw = prstGeom !== undefined
+        ? (((__ts33_1 = prstGeom.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'prst'; })), __ts33_1 == null ? undefined : __ts33_1.value))
+        : undefined;
+    var presetGeometry = prstRaw !== undefined && isStShapeType(prstRaw) ? prstRaw : undefined;
+    var fill = parseFill(spPr);
+    var line = parseLine(spPr, findSpPrElement(spPr, A_NS, 'ln'));
+    var hasThemeStyle = findDeepElement(residual, WPS_NS, 'style') !== undefined;
+    return {
+        presetGeometry: presetGeometry,
+        useCustomGeometry: prstGeom === undefined && custGeom !== undefined,
+        fill: fill,
+        line: line,
+        hasThemeStyle: hasThemeStyle,
+    };
+}
+function parseFill(spPr) {
+    var __ts33_2;
+    if (findSpPrElement(spPr, A_NS, 'noFill') !== undefined) {
+        return { kind: 'none' };
+    }
+    var solid = findSpPrElement(spPr, A_NS, 'solidFill');
+    if (solid !== undefined) {
+        var srgb = solidFillSrgb(solid);
+        if (srgb === undefined) {
+            return { kind: 'theme' };
+        }
+        var alpha = solidFillAlpha(solid);
+        return alpha !== undefined
+            ? { kind: 'solid', srgb: srgb, alpha: alpha }
+            : { kind: 'solid', srgb: srgb };
+    }
+    if (findSpPrElement(spPr, A_NS, 'pattFill') !== undefined) {
+        var patt = findSpPrElement(spPr, A_NS, 'pattFill');
+        var prst = patt !== undefined
+            ? (((__ts33_2 = patt.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'prst'; })), __ts33_2 == null ? undefined : __ts33_2.value))
+            : undefined;
+        return { kind: 'pattern', preset: prst };
+    }
+    // gradFill / blipFill / grpFill are residual by GO; unmodeled → undefined.
+    return undefined;
+}
+function parseLineEnd(parent, localName) {
+    var __ts33_3, __ts33_4;
+    var el = findSpPrElement(parent, A_NS, localName);
+    if (el === undefined) {
+        return { type: undefined, size: undefined };
+    }
+    var typeRaw = ((__ts33_3 = el.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'type'; })), __ts33_3 == null ? undefined : __ts33_3.value);
+    var sizeRaw = ((__ts33_4 = el.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'w'; })), __ts33_4 == null ? undefined : __ts33_4.value);
+    return {
+        type: typeRaw !== undefined && isLineEndType(typeRaw) ? typeRaw : undefined,
+        size: sizeRaw !== undefined && isLineEndSize(sizeRaw) ? sizeRaw : undefined,
+    };
+}
+function parseLine(spPr, lnElement) {
+    var __ts33_5, __ts33_6, __ts33_7;
+    if (lnElement === undefined) {
+        // Absent a:ln: line formatting is inherited from wps:style lnRef (theme) —
+        // never invent a solid color.
+        return {
+            kind: 'theme',
+            widthEmu: undefined,
+            srgbColor: undefined,
+            alpha: undefined,
+            dash: undefined,
+            cap: undefined,
+            beginArrowType: undefined,
+            beginArrowSize: undefined,
+            endArrowType: undefined,
+            endArrowSize: undefined,
+            residual: false,
+        };
+    }
+    // noFill inside a:ln == no line (EG_LineFillProperties choice).
+    var lnNoFill = findSpPrElement(lnElement, A_NS, 'noFill') !== undefined;
+    var lnSolid = findSpPrElement(lnElement, A_NS, 'solidFill');
+    var kind = lnSolid !== undefined ? 'solid' : 'theme';
+    var widthRaw = ((__ts33_5 = lnElement.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'w'; })), __ts33_5 == null ? undefined : __ts33_5.value);
+    var widthEmu = widthRaw !== undefined && /^\d+$/.test(widthRaw)
+        ? Number.parseInt(widthRaw, 10)
+        : undefined;
+    var capRaw = ((__ts33_6 = lnElement.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'cap'; })), __ts33_6 == null ? undefined : __ts33_6.value);
+    var dashEl = findSpPrElement(lnElement, A_NS, 'prstDash');
+    var dashRaw = dashEl !== undefined
+        ? ((__ts33_7 = dashEl.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === 'val'; })), __ts33_7 == null ? undefined : __ts33_7.value) : undefined;
+    var head = parseLineEnd(lnElement, 'headEnd');
+    var tail = parseLineEnd(lnElement, 'tailEnd');
+    var residual = findSpPrElement(lnElement, A_NS, 'custDash') !== undefined ||
+        findSpPrElement(lnElement, A_NS, 'round') !== undefined ||
+        findSpPrElement(lnElement, A_NS, 'bevel') !== undefined ||
+        findSpPrElement(lnElement, A_NS, 'miter') !== undefined ||
+        (dashEl !== undefined && dashRaw !== undefined && !isPresetLineDashWire(dashRaw));
+    return {
+        kind: lnNoFill ? 'none' : kind,
+        widthEmu: widthEmu,
+        srgbColor: lnSolid !== undefined ? solidFillSrgb(lnSolid) : undefined,
+        alpha: lnSolid !== undefined ? solidFillAlpha(lnSolid) : undefined,
+        dash: dashRaw !== undefined && isPresetLineDashWire(dashRaw) ? dashRaw : undefined,
+        cap: capRaw !== undefined && isLineCap(capRaw) ? capRaw : undefined,
+        beginArrowType: head.type,
+        beginArrowSize: head.size,
+        endArrowType: tail.type,
+        endArrowSize: tail.size,
+        residual: residual,
+    };
+}
+function buildSrgbClr(val, alpha) {
+    var children = [];
+    if (alpha !== undefined && alpha >= 0 && alpha < 100000) {
+        children.push({
+            kind: 'element',
+            namespaceUri: A_NS,
+            localName: 'alpha',
+            prefix: 'a',
+            attributes: [
+                { namespaceUri: '', localName: 'val', prefix: '', value: String(Math.round(alpha)) },
+            ],
+            namespaceDeclarations: [],
+            children: [],
+        });
+    }
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: 'srgbClr',
+        prefix: 'a',
+        attributes: [
+            { namespaceUri: '', localName: 'val', prefix: '', value: val.toLowerCase() },
+        ],
+        namespaceDeclarations: [],
+        children: children,
+    };
+}
+function buildSolidFill(srgb, alpha) {
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: 'solidFill',
+        prefix: 'a',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: [buildSrgbClr(srgb, alpha)],
+    };
+}
+function buildNoFill() {
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: 'noFill',
+        prefix: 'a',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: [],
+    };
+}
+/**
+ * Build the fill element for modeled fill MVP. Throws on non-solid/none kinds
+ * (those go through residual).
+ */
+export function buildFillElement(fill) {
+    if (fill.kind === 'solid') {
+        return buildSolidFill(fill.srgb, fill.alpha);
+    }
+    if (fill.kind === 'none') {
+        return buildNoFill();
+    }
+    throw new DocxError('content/invalid-shape', "Only solid or noFill can be authored; kind \"" + String(fill.kind) + "\" is residual");
+}
+function buildHeadTail(localName, type, size) {
+    if (type === undefined && size === undefined) {
+        return undefined;
+    }
+    var attributes = [];
+    if (type !== undefined) {
+        attributes.push({ namespaceUri: '', localName: 'type', prefix: '', value: type });
+    }
+    if (size !== undefined) {
+        attributes.push({ namespaceUri: '', localName: 'w', prefix: '', value: size });
+    }
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: localName,
+        prefix: 'a',
+        attributes: attributes,
+        namespaceDeclarations: [],
+        children: [],
+    };
+}
+/**
+ * Build `a:ln` from the modeled MVP subset; residual line children (join,
+ * custDash) are not re-emitted on this path.
+ */
+export function buildLineElement(line) {
+    var attributes = [];
+    if (line.widthEmu !== undefined) {
+        if (line.widthEmu < 0 || line.widthEmu > LINE_WIDTH_MAX_EMU) {
+            throw new DocxError('content/invalid-shape', "Line width " + String(line.widthEmu) + " EMU outside ST_LineWidth range 0\u202620116800");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'w',
+            prefix: '',
+            value: String(line.widthEmu),
+        });
+    }
+    if (line.cap !== undefined) {
+        attributes.push({ namespaceUri: '', localName: 'cap', prefix: '', value: line.cap });
+    }
+    var children = [];
+    if (line.kind === 'solid') {
+        if (line.srgb === undefined) {
+            throw new DocxError('content/invalid-shape', 'Solid line requires an sRGB color');
+        }
+        children.push(buildSolidFill(line.srgb, line.alpha));
+    }
+    else {
+        children.push(buildNoFill());
+    }
+    if (line.dash !== undefined) {
+        children.push({
+            kind: 'element',
+            namespaceUri: A_NS,
+            localName: 'prstDash',
+            prefix: 'a',
+            attributes: [
+                { namespaceUri: '', localName: 'val', prefix: '', value: line.dash },
+            ],
+            namespaceDeclarations: [],
+            children: [],
+        });
+    }
+    var head = buildHeadTail('headEnd', line.beginArrowType, line.beginArrowSize);
+    if (head !== undefined) {
+        children.push(head);
+    }
+    var tail = buildHeadTail('tailEnd', line.endArrowType, line.endArrowSize);
+    if (tail !== undefined) {
+        children.push(tail);
+    }
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: 'ln',
+        prefix: 'a',
+        attributes: attributes,
+        namespaceDeclarations: [],
+        children: children,
+    };
+}
+/**
+ * Compound line style for shape outlines (public model).
+ * Single is the only modeled style in the current codec; other values stay residual-safe.
+ * @public
+ */
+export var LineStyle = {
+    Single: 'single',
+};
+/**
+ * Arrowhead style at a line end. Maps 1:1 to DrawingML `ST_LineEndType`.
+ * @public
+ */
+export var ArrowheadStyle = {
+    None: 'none',
+    Triangle: 'triangle',
+    Stealth: 'stealth',
+    Diamond: 'diamond',
+    Oval: 'oval',
+    Arrow: 'arrow',
+};
+/**
+ * Arrowhead size (`ST_LineEndWidth` / `ST_LineEndLength`).
+ * @public
+ */
+export var ArrowheadSize = {
+    Small: 'sm',
+    Medium: 'med',
+    Large: 'lg',
+};

package/src/features/drawing/text-frame.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Public TextFrame owned by Shape.
+ * @packageDocumentation
+ */
+import { TextDirection, TextVerticalAlignment } from './body-pr';
+/**
+ * Owner hooks for {@link TextFrame} / {@link InternalMargin}.
+ * @private
+ */
+export interface TextFrameOwner {
+    /** @private */
+    readTextFrameDirection(): TextDirection | undefined;
+    /** @private */
+    writeTextFrameDirection(value: TextDirection): void;
+    /** @private */
+    readTextFrameVerticalAlignment(): TextVerticalAlignment | undefined;
+    /** @private */
+    writeTextFrameVerticalAlignment(value: TextVerticalAlignment): void;
+    /** @private */
+    readInternalMarginLeft(): number;
+    /** @private */
+    writeInternalMarginLeft(value: number): void;
+    /** @private */
+    readInternalMarginTop(): number;
+    /** @private */
+    writeInternalMarginTop(value: number): void;
+    /** @private */
+    readInternalMarginRight(): number;
+    /** @private */
+    writeInternalMarginRight(value: number): void;
+    /** @private */
+    readInternalMarginBottom(): number;
+    /** @private */
+    writeInternalMarginBottom(value: number): void;
+}
+/**
+ * Internal text-frame margins in points (`wps:bodyPr` lIns/tIns/rIns/bIns).
+ * @public
+ */
+export declare class InternalMargin {
+    private readonly owner;
+    /** @private */
+    constructor(owner: TextFrameOwner);
+    /**
+     * Distance between the text and the left shape boundary, in points.
+     * @public
+     */
+    left: number;
+    /**
+     * Distance between the text and the top shape boundary, in points.
+     * @public
+     */
+    top: number;
+    /**
+     * Distance between the text and the right shape boundary, in points.
+     * @public
+     */
+    right: number;
+    /**
+     * Distance between the text and the bottom shape boundary, in points.
+     * @public
+     */
+    bottom: number;
+}
+/**
+ * Text frame body properties (`wps:bodyPr` vertical direction + anchor + insets).
+ * @public
+ */
+export declare class TextFrame {
+    private readonly owner;
+    private readonly internalMarginValue;
+    /** @private */
+    constructor(owner: TextFrameOwner);
+    /**
+     * Text direction (`wps:bodyPr/@vert`).
+     * @public
+     */
+    textDirection: TextDirection;
+    /**
+     * Vertical text alignment inside the frame (`wps:bodyPr/@anchor`).
+     * @public
+     */
+    textVerticalAlignment: TextVerticalAlignment;
+    /**
+     * Internal margins between the shape boundary and its text (points).
+     * The returned object is owned by the text frame for the shape lifetime.
+     * @public
+     */
+    readonly internalMargin: InternalMargin;
+}