@syncfusion/ej2-office-common 35.1.37 → 35.1.43

package/src/office-common/features/mathml/office-math/function-collection.js

@@ -0,0 +1,76 @@
+/**
+ * Collection and factory of Math functions.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { OwnedCollection } from './collection';
+import { MathFunctionType, MathLimitType, MathScriptType } from './enums';
+import { OfficeMathRunElement } from './run-element';
+import { OfficeMathAccent, OfficeMathBar, OfficeMathBorderBox, OfficeMathBox, OfficeMathGroupCharacter, OfficeMathPhantom, OfficeMathRadical } from './functions-basic';
+import { OfficeMathDelimiter, OfficeMathEquationArray, OfficeMathFraction, OfficeMathFunction, OfficeMathLimit, OfficeMathNArray, OfficeMathScript, OfficeMathRightScript, OfficeMathLeftScript } from './functions-multi';
+import { OfficeMathMatrix } from './matrix';
+/**
+ * Creates an unattached function of the given type.
+ *
+ * @param type
+ * @private
+ */
+export function createMathFunction(type) {
+    switch (type) {
+        case MathFunctionType.Accent: return new OfficeMathAccent();
+        case MathFunctionType.Bar: return new OfficeMathBar();
+        case MathFunctionType.BorderBox: return new OfficeMathBorderBox();
+        case MathFunctionType.Box: return new OfficeMathBox();
+        case MathFunctionType.Delimiter: return new OfficeMathDelimiter();
+        case MathFunctionType.EquationArray: return new OfficeMathEquationArray();
+        case MathFunctionType.Fraction: return new OfficeMathFraction();
+        case MathFunctionType.Function: return new OfficeMathFunction();
+        case MathFunctionType.GroupCharacter: return new OfficeMathGroupCharacter();
+        case MathFunctionType.Limit: return new OfficeMathLimit();
+        case MathFunctionType.Matrix: return new OfficeMathMatrix();
+        case MathFunctionType.NArray: return new OfficeMathNArray();
+        case MathFunctionType.Phantom: return new OfficeMathPhantom();
+        case MathFunctionType.Radical: return new OfficeMathRadical();
+        case MathFunctionType.LeftSubSuperscript: return new OfficeMathLeftScript();
+        case MathFunctionType.SubSuperscript: return new OfficeMathScript();
+        case MathFunctionType.RightSubSuperscript: return new OfficeMathRightScript();
+        case MathFunctionType.RunElement: return new OfficeMathRunElement();
+        default: throw new RangeError('Unknown Math function type: ' + String(type));
+    }
+}
+/**
+ * Ordered collection of Math functions with a type-based factory.
+ *
+ * @public
+ */
+var OfficeMathFunctionCollection = /** @class */ (function (_super) {
+    __extends(OfficeMathFunctionCollection, _super);
+    function OfficeMathFunctionCollection(owner) {
+        return _super.call(this, owner) || this;
+    }
+    /**
+     * Creates a function of the given type and appends it, or inserts it at `index`.
+     *
+     * @param type
+     * @param index
+     */
+    OfficeMathFunctionCollection.prototype.add = function (type, index) {
+        var item = createMathFunction(type);
+        this.insertItem(index === undefined ? this.count : index, item);
+        return item;
+    };
+    return OfficeMathFunctionCollection;
+}(OwnedCollection));
+export { OfficeMathFunctionCollection };
+export { MathLimitType, MathScriptType };

package/src/office-common/features/mathml/office-math/functions-basic.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Single-equation Math functions: accent, bar, border box, box, group character, phantom, radical.
+ */
+import { MathFunctionType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMath } from './office-math';
+import { OfficeMathBreak } from './break';
+import { OfficeMathEntity } from './entity';
+/** Accent (`m:acc`). @public */
+export declare class OfficeMathAccent extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Accent;
+    private readonly _equation;
+    constructor(owner?: OfficeMathEntity);
+    /** Accent character. Default U+0302. */
+    accentCharacter: string;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Bar (`m:bar`). @public */
+export declare class OfficeMathBar extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Bar;
+    private readonly _equation;
+    constructor(owner?: OfficeMathEntity);
+    /** Whether the bar is drawn above the base. Default false. */
+    barTop: boolean;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Border box (`m:borderBox`). @public */
+export declare class OfficeMathBorderBox extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.BorderBox;
+    private readonly _equation;
+    constructor(owner?: OfficeMathEntity);
+    /** Hides the top border. Default false. */
+    hideTop: boolean;
+    /** Hides the bottom border. Default false. */
+    hideBottom: boolean;
+    /** Hides the left border. Default false. */
+    hideLeft: boolean;
+    /** Hides the right border. Default false. */
+    hideRight: boolean;
+    /** Diagonal strike from bottom-left to top-right. Default false. */
+    strikeDiagonalUp: boolean;
+    /** Diagonal strike from top-left to bottom-right. Default false. */
+    strikeDiagonalDown: boolean;
+    /** Vertical strike. Default false. */
+    strikeVertical: boolean;
+    /** Horizontal strike. Default false. */
+    strikeHorizontal: boolean;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Box (`m:box`). @public */
+export declare class OfficeMathBox extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Box;
+    private readonly _equation;
+    private _break;
+    constructor(owner?: OfficeMathEntity);
+    /** Operator alignment. Default false. */
+    alignment: boolean;
+    /** Differential. Default false. */
+    enableDifferential: boolean;
+    /** Disallows line breaks inside the box. Default true. */
+    noBreak: boolean;
+    /** Operator emulator. Default false. */
+    operatorEmulator: boolean;
+    /** Optional manual break. Not created automatically. */
+    break: OfficeMathBreak | undefined;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Group character (`m:groupChr`). @public */
+export declare class OfficeMathGroupCharacter extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.GroupCharacter;
+    private readonly _equation;
+    constructor(owner?: OfficeMathEntity);
+    /** Whether the group is aligned top. Default true. */
+    hasAlignTop: boolean;
+    /** Whether the character is drawn on top. Default false. */
+    hasCharacterTop: boolean;
+    /** Grouping character. Default U+23DF. */
+    groupCharacter: string;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Phantom (`m:phant`). @public */
+export declare class OfficeMathPhantom extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Phantom;
+    private readonly _equation;
+    constructor(owner?: OfficeMathEntity);
+    /** Shows the phantom content. Default true. */
+    show: boolean;
+    /** Transparent. Default false. */
+    transparent: boolean;
+    /** Zero ascent. Default false. */
+    zeroAscent: boolean;
+    /** Zero descent. Default false. */
+    zeroDescent: boolean;
+    /** Zero width. Default false. */
+    zeroWidth: boolean;
+    /** Smash. Default false. */
+    smash: boolean;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+}
+/** Radical (`m:rad`). @public */
+export declare class OfficeMathRadical extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Radical;
+    private readonly _equation;
+    private readonly _degree;
+    constructor(owner?: OfficeMathEntity);
+    /** Hides the degree. Default false. */
+    hideDegree: boolean;
+    /** Degree equation. */
+    readonly degree: OfficeMath;
+    /** Radicand equation. */
+    readonly equation: OfficeMath;
+}

package/src/office-common/features/mathml/office-math/functions-basic.js

@@ -0,0 +1,331 @@
+/**
+ * Single-equation Math functions: accent, bar, border box, box, group character, phantom, radical.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { MathFunctionType } from './enums';
+import { K } from './keys';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMath } from './office-math';
+/** Accent (`m:acc`). @public */
+var OfficeMathAccent = /** @class */ (function (_super) {
+    __extends(OfficeMathAccent, _super);
+    function OfficeMathAccent(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Accent;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathAccent.prototype, "accentCharacter", {
+        /** Accent character. Default U+0302. */
+        get: function () { return this.getProperty(K.AccentChar, function () { return String.fromCharCode(770); }); },
+        set: function (value) { this.setProperty(K.AccentChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathAccent.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathAccent;
+}(OfficeMathFunctionBase));
+export { OfficeMathAccent };
+/** Bar (`m:bar`). @public */
+var OfficeMathBar = /** @class */ (function (_super) {
+    __extends(OfficeMathBar, _super);
+    function OfficeMathBar(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Bar;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathBar.prototype, "barTop", {
+        /** Whether the bar is drawn above the base. Default false. */
+        get: function () { return this.getProperty(K.BarTop, function () { return false; }); },
+        set: function (value) { this.setProperty(K.BarTop, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBar.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathBar;
+}(OfficeMathFunctionBase));
+export { OfficeMathBar };
+/** Border box (`m:borderBox`). @public */
+var OfficeMathBorderBox = /** @class */ (function (_super) {
+    __extends(OfficeMathBorderBox, _super);
+    function OfficeMathBorderBox(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.BorderBox;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathBorderBox.prototype, "hideTop", {
+        /** Hides the top border. Default false. */
+        get: function () { return this.getProperty(K.HideTop, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideTop, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "hideBottom", {
+        /** Hides the bottom border. Default false. */
+        get: function () { return this.getProperty(K.HideBottom, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideBottom, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "hideLeft", {
+        /** Hides the left border. Default false. */
+        get: function () { return this.getProperty(K.HideLeft, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideLeft, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "hideRight", {
+        /** Hides the right border. Default false. */
+        get: function () { return this.getProperty(K.HideRight, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideRight, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "strikeDiagonalUp", {
+        /** Diagonal strike from bottom-left to top-right. Default false. */
+        get: function () { return this.getProperty(K.StrikeBLTR, function () { return false; }); },
+        set: function (value) { this.setProperty(K.StrikeBLTR, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "strikeDiagonalDown", {
+        /** Diagonal strike from top-left to bottom-right. Default false. */
+        get: function () { return this.getProperty(K.StrikeTLBR, function () { return false; }); },
+        set: function (value) { this.setProperty(K.StrikeTLBR, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "strikeVertical", {
+        /** Vertical strike. Default false. */
+        get: function () { return this.getProperty(K.StrikeVertical, function () { return false; }); },
+        set: function (value) { this.setProperty(K.StrikeVertical, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "strikeHorizontal", {
+        /** Horizontal strike. Default false. */
+        get: function () { return this.getProperty(K.StrikeHorizontal, function () { return false; }); },
+        set: function (value) { this.setProperty(K.StrikeHorizontal, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBorderBox.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathBorderBox;
+}(OfficeMathFunctionBase));
+export { OfficeMathBorderBox };
+/** Box (`m:box`). @public */
+var OfficeMathBox = /** @class */ (function (_super) {
+    __extends(OfficeMathBox, _super);
+    function OfficeMathBox(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Box;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathBox.prototype, "alignment", {
+        /** Operator alignment. Default false. */
+        get: function () { return this.getProperty(K.BoxAlign, function () { return false; }); },
+        set: function (value) { this.setProperty(K.BoxAlign, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBox.prototype, "enableDifferential", {
+        /** Differential. Default false. */
+        get: function () { return this.getProperty(K.EnableDifferential, function () { return false; }); },
+        set: function (value) { this.setProperty(K.EnableDifferential, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBox.prototype, "noBreak", {
+        /** Disallows line breaks inside the box. Default true. */
+        get: function () { return this.getProperty(K.NoBreak, function () { return true; }); },
+        set: function (value) { this.setProperty(K.NoBreak, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBox.prototype, "operatorEmulator", {
+        /** Operator emulator. Default false. */
+        get: function () { return this.getProperty(K.OperatorEmulator, function () { return false; }); },
+        set: function (value) { this.setProperty(K.OperatorEmulator, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBox.prototype, "break", {
+        /** Optional manual break. Not created automatically. */
+        get: function () { return this._break; },
+        set: function (value) {
+            this._break = value;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBox.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathBox;
+}(OfficeMathFunctionBase));
+export { OfficeMathBox };
+/** Group character (`m:groupChr`). @public */
+var OfficeMathGroupCharacter = /** @class */ (function (_super) {
+    __extends(OfficeMathGroupCharacter, _super);
+    function OfficeMathGroupCharacter(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.GroupCharacter;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathGroupCharacter.prototype, "hasAlignTop", {
+        /** Whether the group is aligned top. Default true. */
+        get: function () { return this.getProperty(K.HasAlignTop, function () { return true; }); },
+        set: function (value) { this.setProperty(K.HasAlignTop, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathGroupCharacter.prototype, "hasCharacterTop", {
+        /** Whether the character is drawn on top. Default false. */
+        get: function () { return this.getProperty(K.HasCharTop, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HasCharTop, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathGroupCharacter.prototype, "groupCharacter", {
+        /** Grouping character. Default U+23DF. */
+        get: function () { return this.getProperty(K.GroupChar, function () { return String.fromCharCode(9183); }); },
+        set: function (value) { this.setProperty(K.GroupChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathGroupCharacter.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathGroupCharacter;
+}(OfficeMathFunctionBase));
+export { OfficeMathGroupCharacter };
+/** Phantom (`m:phant`). @public */
+var OfficeMathPhantom = /** @class */ (function (_super) {
+    __extends(OfficeMathPhantom, _super);
+    function OfficeMathPhantom(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Phantom;
+        _this._equation = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathPhantom.prototype, "show", {
+        /** Shows the phantom content. Default true. */
+        get: function () { return this.getProperty(K.Show, function () { return true; }); },
+        set: function (value) { this.setProperty(K.Show, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "transparent", {
+        /** Transparent. Default false. */
+        get: function () { return this.getProperty(K.Transparent, function () { return false; }); },
+        set: function (value) { this.setProperty(K.Transparent, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "zeroAscent", {
+        /** Zero ascent. Default false. */
+        get: function () { return this.getProperty(K.ZeroAscent, function () { return false; }); },
+        set: function (value) { this.setProperty(K.ZeroAscent, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "zeroDescent", {
+        /** Zero descent. Default false. */
+        get: function () { return this.getProperty(K.ZeroDescent, function () { return false; }); },
+        set: function (value) { this.setProperty(K.ZeroDescent, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "zeroWidth", {
+        /** Zero width. Default false. */
+        get: function () { return this.getProperty(K.ZeroWidth, function () { return false; }); },
+        set: function (value) { this.setProperty(K.ZeroWidth, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "smash", {
+        /** Smash. Default false. */
+        get: function () { return this.getProperty(K.Smash, function () { return false; }); },
+        set: function (value) { this.setProperty(K.Smash, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathPhantom.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathPhantom;
+}(OfficeMathFunctionBase));
+export { OfficeMathPhantom };
+/** Radical (`m:rad`). @public */
+var OfficeMathRadical = /** @class */ (function (_super) {
+    __extends(OfficeMathRadical, _super);
+    function OfficeMathRadical(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Radical;
+        _this._equation = new OfficeMath(_this);
+        _this._degree = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathRadical.prototype, "hideDegree", {
+        /** Hides the degree. Default false. */
+        get: function () { return this.getProperty(K.HideDegree, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideDegree, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRadical.prototype, "degree", {
+        /** Degree equation. */
+        get: function () { return this._degree; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRadical.prototype, "equation", {
+        /** Radicand equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathRadical;
+}(OfficeMathFunctionBase));
+export { OfficeMathRadical };

package/src/office-common/features/mathml/office-math/functions-multi.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Multi-equation Math functions: delimiter, equation array, fraction, function, limit, n-ary, scripts.
+ */
+import { MathFunctionType, MathDelimiterShapeType, MathFractionType, MathLimitType, MathScriptType, MathVerticalAlignment, SpacingRule } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMath } from './office-math';
+import { OfficeMathCollection } from './math-collection';
+import { OfficeMathEntity } from './entity';
+/** Delimiter (`m:d`). @public */
+export declare class OfficeMathDelimiter extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Delimiter;
+    private readonly _equations;
+    constructor(owner?: OfficeMathEntity);
+    /** Opening character. Default `(`. */
+    beginCharacter: string;
+    /** Closing character. Default `)`. */
+    endCharacter: string;
+    /** Separator character. Default `|`. */
+    separator: string;
+    /** Whether delimiters grow with content. Default true. */
+    isGrow: boolean;
+    /** Delimiter shape. Default centered. */
+    delimiterShape: MathDelimiterShapeType;
+    /** Argument equations. */
+    readonly equations: OfficeMathCollection;
+}
+/**
+ * Validates a row spacing value against its rule.
+ *
+ * @param value
+ * @param rule
+ * @private
+ */
+export declare function checkRowSpacing(value: number, rule: SpacingRule): void;
+/** Equation array (`m:eqArr`). @public */
+export declare class OfficeMathEquationArray extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.EquationArray;
+    private readonly _equations;
+    constructor(owner?: OfficeMathEntity);
+    /** Vertical alignment. Default center. */
+    verticalAlignment: MathVerticalAlignment;
+    /** Expand container. Default false. */
+    expandEquationContainer: boolean;
+    /** Expand content. Default false. */
+    expandEquationContent: boolean;
+    /** Row spacing; unit depends on `rowSpacingRule` (points for Exactly, lines for Multiple). Default 0. */
+    rowSpacing: number;
+    /** Row spacing rule. Default single. */
+    rowSpacingRule: SpacingRule;
+    /** Row equations. */
+    readonly equations: OfficeMathCollection;
+}
+/** Fraction (`m:f`). @public */
+export declare class OfficeMathFraction extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Fraction;
+    private readonly _numerator;
+    private readonly _denominator;
+    constructor(owner?: OfficeMathEntity);
+    /** Fraction type. Default normal bar. */
+    fractionType: MathFractionType;
+    /** Numerator. */
+    readonly numerator: OfficeMath;
+    /** Denominator. */
+    readonly denominator: OfficeMath;
+}
+/** Function application (`m:func`). @public */
+export declare class OfficeMathFunction extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Function;
+    private readonly _equation;
+    private readonly _functionName;
+    constructor(owner?: OfficeMathEntity);
+    /** Argument equation. */
+    readonly equation: OfficeMath;
+    /** Function name equation. */
+    readonly functionName: OfficeMath;
+}
+/** Lower or upper limit (`m:limLow` / `m:limUpp`). @public */
+export declare class OfficeMathLimit extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Limit;
+    private readonly _equation;
+    private readonly _limit;
+    constructor(owner?: OfficeMathEntity);
+    /** Lower or upper limit. Default lower. */
+    limitType: MathLimitType;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+    /** Limit equation. */
+    readonly limit: OfficeMath;
+}
+/** N-ary operator (`m:nary`). @public */
+export declare class OfficeMathNArray extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.NArray;
+    private readonly _equation;
+    private readonly _subscript;
+    private readonly _superscript;
+    constructor(owner?: OfficeMathEntity);
+    /** Operator character. Default U+222B. */
+    nArrayCharacter: string;
+    /** Whether the operator grows. Default false. */
+    hasGrow: boolean;
+    /** Hides the lower limit. Default false. */
+    hideLowerLimit: boolean;
+    /** Hides the upper limit. Default false. */
+    hideUpperLimit: boolean;
+    /** Limits as sub/superscript. Default true for the integral character, false otherwise. */
+    subSuperscriptLimit: boolean;
+    /** Operand equation. */
+    readonly equation: OfficeMath;
+    /** Lower limit equation. */
+    readonly subscript: OfficeMath;
+    /** Upper limit equation. */
+    readonly superscript: OfficeMath;
+}
+/** Single subscript or superscript (`m:sSub` / `m:sSup`). @public */
+export declare class OfficeMathScript extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.SubSuperscript;
+    private readonly _equation;
+    private readonly _script;
+    constructor(owner?: OfficeMathEntity);
+    /** Subscript or superscript. Default superscript. */
+    scriptType: MathScriptType;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+    /** Script equation. */
+    readonly script: OfficeMath;
+}
+/** Combined right sub/superscript (`m:sSubSup`). @public */
+export declare class OfficeMathRightScript extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.RightSubSuperscript;
+    private readonly _equation;
+    private readonly _subscript;
+    private readonly _superscript;
+    constructor(owner?: OfficeMathEntity);
+    /** Align scripts. Default true. */
+    isSkipAlign: boolean;
+    /** Base equation. */
+    readonly equation: OfficeMath;
+    /** Subscript equation. */
+    readonly subscript: OfficeMath;
+    /** Superscript equation. */
+    readonly superscript: OfficeMath;
+}
+/** Left sub/superscript (`m:sPre`). @public */
+export declare class OfficeMathLeftScript extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.LeftSubSuperscript;
+    private readonly _equation;
+    private readonly _subscript;
+    private readonly _superscript;
+    constructor(owner?: OfficeMathEntity);
+    /** Base equation. */
+    readonly equation: OfficeMath;
+    /** Subscript equation. */
+    readonly subscript: OfficeMath;
+    /** Superscript equation. */
+    readonly superscript: OfficeMath;
+}