@syncfusion/ej2-office-common 35.1.37 → 35.1.43

package/src/features/mathml/model/controls.d.ts

@@ -1,896 +0,0 @@
-/**
- * Typed OMML control classes (EG_OMathMathElements).
- *
- * Source: ECMA-376-4 Annex A.8.1; mathml-spec §7 / §11.2.
- * Constructors take props bag + fixed-sequence children (no boolean traps).
- */
-import { OpenXmlElement } from '../openxml';
-import { MathFractionType, MathLimLoc, MathScript, MathShape, MathStyle, MathTopBot } from './enums';
-import { MathArgument, MathElement } from './math-element';
-/** Opaque ctrlPr carrier shared by property bags. */
-export declare type MathCtrlPr = OpenXmlElement | undefined;
-/**
- * `m:accPr` — accent character.
- *
- * `ctrlPr` is intentionally omitted from the public bag; it is carried only on
- * the wire model via internal parse/serialize channels and must not be exposed.
- */
-export interface MathAccentProperties {
-    /** Accent character (`m:chr`). */
-    chr?: string;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:barPr` — top/bot position. */
-export interface MathBarProperties {
-    /** Bar position (`m:pos`). */
-    pos?: MathTopBot;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:boxPr`. */
-export interface MathBoxProperties {
-    /** Whether the box emulates an operator (`m:opEmu`). */
-    isOperatorEmulated?: boolean;
-    /** Whether line breaking inside the box is forbidden (`m:noBreak`). */
-    isNoBreak?: boolean;
-    /** Whether the box acts as a differential (`m:diff`). */
-    isDifferential?: boolean;
-    /** Whether the box participates in alignment (`m:aln`). */
-    isAligned?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:borderBoxPr`. */
-export interface MathBorderBoxProperties {
-    /** Whether the top border is hidden (`m:hideTop`). */
-    isTopHidden?: boolean;
-    /** Whether the bottom border is hidden (`m:hideBot`). */
-    isBottomHidden?: boolean;
-    /** Whether the left border is hidden (`m:hideLeft`). */
-    isLeftHidden?: boolean;
-    /** Whether the right border is hidden (`m:hideRight`). */
-    isRightHidden?: boolean;
-    /** Whether a horizontal strike is drawn (`m:strikeH`). */
-    hasHorizontalStrike?: boolean;
-    /** Whether a vertical strike is drawn (`m:strikeV`). */
-    hasVerticalStrike?: boolean;
-    /** Whether a bottom-left to top-right diagonal strike is drawn (`m:strikeBLTR`). */
-    hasBottomLeftToTopRightStrike?: boolean;
-    /** Whether a top-left to bottom-right diagonal strike is drawn (`m:strikeTLBR`). */
-    hasTopLeftToBottomRightStrike?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:dPr` — delimiter properties. */
-export interface MathDelimiterProperties {
-    /** Beginning delimiter character (`m:begChr`). */
-    begChr?: string;
-    /** Separator character between arguments (`m:sepChr`). */
-    sepChr?: string;
-    /** Ending delimiter character (`m:endChr`). */
-    endChr?: string;
-    /** Whether delimiter glyphs may grow to match content height (`m:grow`). */
-    canGrow?: boolean;
-    /** ST_Shp: centered | match only. */
-    shp?: MathShape;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:eqArrPr`. */
-export interface MathEquationArrayProperties {
-    /** Base vertical justification (`m:baseJc`). */
-    baseJc?: string;
-    /** Whether maximum distribution spacing is enabled (`m:maxDist`). */
-    hasMaxDistance?: boolean;
-    /** Whether object distribution spacing is enabled (`m:objDist`). */
-    hasObjectDistance?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:fPr` — fraction type. */
-export interface MathFractionProperties {
-    /** ST_FType: bar | skw | lin | noBar. */
-    type?: MathFractionType;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:funcPr`. */
-export interface MathFunctionProperties {
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:groupChrPr`. */
-export interface MathGroupCharacterProperties {
-    /** Group character (`m:chr`). */
-    chr?: string;
-    /** Character position (`m:pos`). */
-    pos?: MathTopBot;
-    /** Vertical justification of the group character (`m:vertJc`). */
-    vertJc?: MathTopBot;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:limLowPr` / `m:limUppPr`. */
-export interface MathLimitProperties {
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:mPr`. */
-export interface MathMatrixProperties {
-    /** Base vertical justification (`m:baseJc`). */
-    baseJc?: string;
-    /** Whether placeholders are hidden (`m:plcHide`). */
-    isPlaceholderHidden?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:naryPr`. */
-export interface MathNaryProperties {
-    /** N-ary operator character (`m:chr`). */
-    chr?: string;
-    /** Limit location (`m:limLoc`). */
-    limLoc?: MathLimLoc;
-    /** Whether the n-ary operator glyph may grow (`m:grow`). */
-    canGrow?: boolean;
-    /** Whether the subscript limit is hidden (`m:subHide`). */
-    isSubscriptHidden?: boolean;
-    /** Whether the superscript limit is hidden (`m:supHide`). */
-    isSuperscriptHidden?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:phantPr`. */
-export interface MathPhantomProperties {
-    /** Whether the phantom contents are shown (`m:show`). */
-    isShown?: boolean;
-    /** Whether the phantom contributes zero width (`m:zeroWid`). */
-    isZeroWidth?: boolean;
-    /** Whether the phantom contributes zero ascent (`m:zeroAsc`). */
-    isZeroAscender?: boolean;
-    /** Whether the phantom contributes zero descent (`m:zeroDesc`). */
-    isZeroDescender?: boolean;
-    /** Whether the phantom is transparent for spacing (`m:transp`). */
-    isTransparent?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** `m:radPr`. */
-export interface MathRadicalProperties {
-    /** Whether the degree is hidden (`m:degHide`). */
-    isDegreeHidden?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/** Shared script-control props (`sPre`/`sSub`/`sSup`/`sSubSup`). */
-export interface MathScriptControlProperties {
-    /** Whether scripts are alignment-aligned (`m:alnScr`). */
-    isScriptAligned?: boolean;
-    /**
-     * Opaque control properties carrier (`m:ctrlPr`).
-     * @private
-     * Not part of the public MathML authoring API.
-     */
-    ctrlPr?: MathCtrlPr;
-}
-/**
- * `m:rPr` math run properties.
- *
- * Source: ECMA-376-4 `CT_RPR` — lit?, nor? | (scr?, sty?), brk?, aln?.
- */
-export interface MathRunProperties {
-    /** Whether the run is treated as literal text (`m:lit`). */
-    isLiteral?: boolean;
-    /** Whether the run uses normal text styling (`m:nor`). */
-    isNormal?: boolean;
-    /** Math script (`m:scr`). */
-    scr?: MathScript;
-    /** Math style (`m:sty`). */
-    sty?: MathStyle;
-    /** Whether the run is an alignment point (`m:aln`). */
-    isAligned?: boolean;
-    /** Break value (ST_Integer255 when modeled as break index). */
-    brk?: number;
-}
-/**
- * Accent math structure — a base expression with a combining accent character.
- *
- * @public
- */
-export declare class MathAccent extends MathElement {
-    /**
-     * Discriminator for this math control kind.
-     *
-     * @public
-     */
-    readonly type = "acc";
-    private _properties;
-    private _base;
-    constructor(properties?: MathAccentProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Gets or sets accent configuration such as the accent character.
-     *
-     * @public
-     */
-    properties: Readonly<MathAccentProperties>;
-    /**
-     * Gets or sets the base mathematical expression under the accent.
-     *
-     * @public
-     */
-    base: MathArgument;
-}
-/**
- * Over/under bar structure (`m:bar`) — a base expression with a bar accent.
- *
- * Child sequence: `barPr?`, `e`.
- *
- * @public
- */
-export declare class MathBar extends MathElement {
-    /**
-     * Math element type for this control (`bar`).
-     */
-    readonly type = "bar";
-    private _properties;
-    private _base;
-    constructor(properties?: MathBarProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Bar configuration (`m:barPr`), such as bar position (`pos`).
-     */
-    properties: Readonly<MathBarProperties>;
-    /**
-     * Base mathematical expression under the bar (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Layout box structure (`m:box`) — groups a base for operator emulation and breaks.
- *
- * Child sequence: `boxPr?`, `e`.
- *
- * @public
- */
-export declare class MathBox extends MathElement {
-    /**
-     * Math element type for this control (`box`).
-     */
-    readonly type = "box";
-    private _properties;
-    private _base;
-    constructor(properties?: MathBoxProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Box configuration (`m:boxPr`), such as operator emulation and break flags.
-     */
-    properties: Readonly<MathBoxProperties>;
-    /**
-     * Base mathematical expression inside the box (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Border box structure (`m:borderBox`) — a base expression with optional borders and strikes.
- *
- * Child sequence: `borderBoxPr?`, `e`.
- *
- * @public
- */
-export declare class MathBorderBox extends MathElement {
-    /**
-     * Math element type for this control (`borderBox`).
-     */
-    readonly type = "borderBox";
-    private _properties;
-    private _base;
-    constructor(properties?: MathBorderBoxProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Border-box configuration (`m:borderBoxPr`), such as hidden sides and strike flags.
-     */
-    properties: Readonly<MathBorderBoxProperties>;
-    /**
-     * Base mathematical expression inside the border box (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Delimiter structure (`m:d`) — one or more arguments between begin/end characters.
- *
- * Child sequence: `dPr?`, `e` (1..∞).
- *
- * @public
- */
-export declare class MathDelimiter extends MathElement {
-    /**
-     * Math element type for this control (`d`).
-     */
-    readonly type = "d";
-    private _properties;
-    private _elements;
-    constructor(properties?: MathDelimiterProperties, elements?: ReadonlyArray<MathArgument | ReadonlyArray<MathElement>>);
-    /**
-     * Delimiter configuration (`m:dPr`), such as begin/end characters and grow.
-     */
-    properties: Readonly<MathDelimiterProperties>;
-    /**
-     * Ordered delimiter arguments (`m:e`), each an {@link MathArgument}.
-     */
-    /**
-    * Replaces the ordered delimiter arguments (`m:e`) in document order.
-    */
-    elements: ReadonlyArray<MathArgument>;
-    /**
-     * Validates that this delimiter has at least one argument before serialization.
-     *
-     * @private
-     * Called by the OMML serializer; not part of the public authoring API.
-     */
-    assertSerializable(path?: string): void;
-}
-/**
- * Equation array structure (`m:eqArr`) — stacked equation rows as arguments.
- *
- * Child sequence: `eqArrPr?`, `e` (1..∞).
- *
- * @public
- */
-export declare class MathEquationArray extends MathElement {
-    /**
-     * Math element type for this control (`eqArr`).
-     */
-    readonly type = "eqArr";
-    private _properties;
-    private _elements;
-    constructor(properties?: MathEquationArrayProperties, elements?: ReadonlyArray<MathArgument | ReadonlyArray<MathElement>>);
-    /**
-     * Equation-array configuration (`m:eqArrPr`), such as base justification and distribution.
-     */
-    properties: Readonly<MathEquationArrayProperties>;
-    /**
-     * Ordered equation-array rows (`m:e`), each an {@link MathArgument}.
-     */
-    /**
-    * Replaces the ordered equation-array rows (`m:e`) in document order.
-    */
-    elements: ReadonlyArray<MathArgument>;
-    /**
-     * Validates that this equation array has at least one row before serialization.
-     *
-     * @private
-     * Called by the OMML serializer; not part of the public authoring API.
-     */
-    assertSerializable(path?: string): void;
-}
-/**
- * Fraction math structure — numerator over denominator with optional fraction style.
- *
- * @public
- */
-export declare class MathFraction extends MathElement {
-    /**
-     * Discriminator for this math control kind.
-     *
-     * @public
-     */
-    readonly type = "f";
-    private _properties;
-    private _numerator;
-    private _denominator;
-    constructor(properties?: MathFractionProperties, numerator?: MathArgument | ReadonlyArray<MathElement>, denominator?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Gets or sets fraction configuration such as bar, skewed, linear, or no-bar style.
-     *
-     * @public
-     */
-    properties: Readonly<MathFractionProperties>;
-    /**
-     * Gets or sets the numerator of the fraction.
-     *
-     * @public
-     */
-    numerator: MathArgument;
-    /**
-     * Gets or sets the denominator of the fraction.
-     *
-     * @public
-     */
-    denominator: MathArgument;
-}
-/**
- * Function-apply structure (`m:func`) — function name applied to a base expression.
- *
- * Child sequence: `funcPr?`, `fName`, `e`.
- *
- * @public
- */
-export declare class MathFunction extends MathElement {
-    /**
-     * Math element type for this control (`func`).
-     */
-    readonly type = "func";
-    private _properties;
-    private _name;
-    private _base;
-    constructor(properties?: MathFunctionProperties, name?: MathArgument | ReadonlyArray<MathElement>, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Function-apply configuration (`m:funcPr`).
-     */
-    properties: Readonly<MathFunctionProperties>;
-    /**
-     * Function name argument (`m:fName`), for example `sin` or `log`.
-     */
-    name: MathArgument;
-    /**
-     * Base mathematical expression the function applies to (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Group-character structure (`m:groupChr`) — a base with a grouping character above or below.
- *
- * Child sequence: `groupChrPr?`, `e`.
- *
- * @public
- */
-export declare class MathGroupCharacter extends MathElement {
-    /**
-     * Math element type for this control (`groupChr`).
-     */
-    readonly type = "groupChr";
-    private _properties;
-    private _base;
-    constructor(properties?: MathGroupCharacterProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Group-character configuration (`m:groupChrPr`), such as character and position.
-     */
-    properties: Readonly<MathGroupCharacterProperties>;
-    /**
-     * Base mathematical expression under the group character (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Lower-limit structure (`m:limLow`) — a base expression with a limit below it.
- *
- * Child sequence: `limLowPr?`, `e`, `lim`.
- *
- * @public
- */
-export declare class MathLimitLower extends MathElement {
-    /**
-     * Math element type for this control (`limLow`).
-     */
-    readonly type = "limLow";
-    private _properties;
-    private _base;
-    private _lim;
-    constructor(properties?: MathLimitProperties, base?: MathArgument | ReadonlyArray<MathElement>, lim?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Lower-limit configuration (`m:limLowPr`).
-     */
-    properties: Readonly<MathLimitProperties>;
-    /**
-     * Base mathematical expression above the lower limit (`m:e`).
-     */
-    base: MathArgument;
-    /**
-     * Lower-limit argument drawn beneath the base (`m:lim`).
-     */
-    lim: MathArgument;
-}
-/**
- * Upper-limit structure (`m:limUpp`) — a base expression with a limit above it.
- *
- * Child sequence: `limUppPr?`, `e`, `lim`.
- *
- * @public
- */
-export declare class MathLimitUpper extends MathElement {
-    /**
-     * Math element type for this control (`limUpp`).
-     */
-    readonly type = "limUpp";
-    private _properties;
-    private _base;
-    private _lim;
-    constructor(properties?: MathLimitProperties, base?: MathArgument | ReadonlyArray<MathElement>, lim?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Upper-limit configuration (`m:limUppPr`).
-     */
-    properties: Readonly<MathLimitProperties>;
-    /**
-     * Base mathematical expression below the upper limit (`m:e`).
-     */
-    base: MathArgument;
-    /**
-     * Upper-limit argument drawn above the base (`m:lim`).
-     */
-    lim: MathArgument;
-}
-/**
- * Matrix row (`m:mr`) — one row of matrix cell arguments.
- *
- * Child sequence: `e` (1..∞).
- *
- * @public
- */
-export declare class MathMatrixRow extends MathElement {
-    /**
-     * Math element type for this control (`mr`).
-     */
-    readonly type = "mr";
-    private _elements;
-    constructor(elements?: ReadonlyArray<MathArgument | ReadonlyArray<MathElement>>);
-    /**
-     * Ordered cell arguments in this matrix row (`m:e`), each an {@link MathArgument}.
-     */
-    readonly elements: ReadonlyArray<MathArgument>;
-    /**
-     * Replaces the ordered cell arguments (`m:e`) in this matrix row.
-     */
-    setElements(next: ReadonlyArray<MathArgument>): void;
-    /**
-     * Validates that this matrix row has at least one cell before serialization.
-     *
-     * @private
-     * Called by the OMML serializer; not part of the public authoring API.
-     */
-    assertSerializable(path?: string): void;
-}
-/**
- * Matrix structure (`m:m`) — a grid of matrix rows.
- *
- * Child sequence: `mPr?`, `mr` (1..∞).
- *
- * @public
- */
-export declare class MathMatrix extends MathElement {
-    /**
-     * Math element type for this control (`m`).
-     */
-    readonly type = "m";
-    private _properties;
-    private _rows;
-    constructor(properties?: MathMatrixProperties, rows?: ReadonlyArray<MathMatrixRow>);
-    /**
-     * Matrix configuration (`m:mPr`), such as base justification and placeholder visibility.
-     */
-    properties: Readonly<MathMatrixProperties>;
-    /**
-     * Ordered matrix rows (`m:mr`), each a {@link MathMatrixRow}.
-     */
-    readonly rows: ReadonlyArray<MathMatrixRow>;
-    /**
-     * Replaces the ordered matrix rows (`m:mr`) in document order.
-     */
-    setRows(next: ReadonlyArray<MathMatrixRow>): void;
-    /**
-     * Validates that this matrix has at least one row (and each row is valid) before serialization.
-     *
-     * @private
-     * Called by the OMML serializer; not part of the public authoring API.
-     */
-    assertSerializable(path?: string): void;
-}
-/**
- * N-ary operator structure (`m:nary`) — integral, sum, product, and similar operators.
- *
- * Child sequence: `naryPr?`, `sub`, `sup`, `e`.
- *
- * @public
- */
-export declare class MathNaryOperator extends MathElement {
-    /**
-     * Math element type for this control (`nary`).
-     */
-    readonly type = "nary";
-    private _properties;
-    private _sub;
-    private _sup;
-    private _base;
-    constructor(properties?: MathNaryProperties, sub?: MathArgument | ReadonlyArray<MathElement>, sup?: MathArgument | ReadonlyArray<MathElement>, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * N-ary operator configuration (`m:naryPr`), such as operator character, limit location, and hide flags.
-     */
-    properties: Readonly<MathNaryProperties>;
-    /**
-     * Lower (subscript) limit of the n-ary operator (`m:sub`).
-     */
-    subscript: MathArgument;
-    /**
-     * Upper (superscript) limit of the n-ary operator (`m:sup`).
-     */
-    superscript: MathArgument;
-    /**
-     * Base mathematical expression the n-ary operator applies to (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Phantom structure (`m:phant`) — layout spacing from content that may be hidden.
- *
- * Child sequence: `phantPr?`, `e`.
- *
- * @public
- */
-export declare class MathPhantom extends MathElement {
-    /**
-     * Math element type for this control (`phant`).
-     */
-    readonly type = "phant";
-    private _properties;
-    private _base;
-    constructor(properties?: MathPhantomProperties, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Phantom configuration (`m:phantPr`), such as show and zero-width/ascender/descender flags.
-     */
-    properties: Readonly<MathPhantomProperties>;
-    /**
-     * Base mathematical expression used for phantom layout (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Radical structure (`m:rad`) — square root or nth-root with optional degree.
- *
- * Child sequence: `radPr?`, `deg`, `e`.
- *
- * @public
- */
-export declare class MathRadical extends MathElement {
-    /**
-     * Math element type for this control (`rad`).
-     */
-    readonly type = "rad";
-    private _properties;
-    private _deg;
-    private _base;
-    constructor(properties?: MathRadicalProperties, deg?: MathArgument | ReadonlyArray<MathElement>, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Radical configuration (`m:radPr`), such as whether the degree is hidden.
-     */
-    properties: Readonly<MathRadicalProperties>;
-    /**
-     * Degree argument of the radical (`m:deg`), for example the index of an nth root.
-     */
-    deg: MathArgument;
-    /**
-     * Radicand — the expression under the radical sign (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Pre-sub-superscript structure (`m:sPre`) — scripts placed before the base.
- *
- * Child sequence: `sPrePr?`, `sub`, `sup`, `e`.
- *
- * @public
- */
-export declare class MathPreSubSuperscript extends MathElement {
-    /**
-     * Math element type for this control (`sPre`).
-     */
-    readonly type = "sPre";
-    private _properties;
-    private _sub;
-    private _sup;
-    private _base;
-    constructor(properties?: MathScriptControlProperties, sub?: MathArgument | ReadonlyArray<MathElement>, sup?: MathArgument | ReadonlyArray<MathElement>, base?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Pre-script configuration (`m:sPrePr`), such as script alignment.
-     */
-    properties: Readonly<MathScriptControlProperties>;
-    /**
-     * Subscript argument placed before the base (`m:sub`).
-     */
-    sub: MathArgument;
-    /**
-     * Superscript argument placed before the base (`m:sup`).
-     */
-    sup: MathArgument;
-    /**
-     * Base mathematical expression after the pre-scripts (`m:e`).
-     */
-    base: MathArgument;
-}
-/**
- * Subscript structure (`m:sSub`) — a base with a subscript.
- *
- * Child sequence: `sSubPr?`, `e`, `sub`.
- *
- * @public
- */
-export declare class MathSubscript extends MathElement {
-    /**
-     * Math element type for this control (`sSub`).
-     */
-    readonly type = "sSub";
-    private _properties;
-    private _base;
-    private _sub;
-    constructor(properties?: MathScriptControlProperties, base?: MathArgument | ReadonlyArray<MathElement>, sub?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Subscript configuration (`m:sSubPr`), such as script alignment.
-     */
-    properties: Readonly<MathScriptControlProperties>;
-    /**
-     * Base mathematical expression carrying the subscript (`m:e`).
-     */
-    base: MathArgument;
-    /**
-     * Subscript argument (`m:sub`).
-     */
-    subscript: MathArgument;
-}
-/**
- * Sub-superscript structure (`m:sSubSup`) — a base with both subscript and superscript.
- *
- * Child sequence: `sSubSupPr?`, `e`, `sub`, `sup`.
- *
- * @public
- */
-export declare class MathSubSuperscript extends MathElement {
-    /**
-     * Math element type for this control (`sSubSup`).
-     */
-    readonly type = "sSubSup";
-    private _properties;
-    private _base;
-    private _sub;
-    private _sup;
-    constructor(properties?: MathScriptControlProperties, base?: MathArgument | ReadonlyArray<MathElement>, sub?: MathArgument | ReadonlyArray<MathElement>, sup?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Sub-superscript configuration (`m:sSubSupPr`), such as script alignment.
-     */
-    properties: Readonly<MathScriptControlProperties>;
-    /**
-     * Base mathematical expression carrying both scripts (`m:e`).
-     */
-    base: MathArgument;
-    /**
-     * Subscript argument (`m:sub`).
-     */
-    subscript: MathArgument;
-    /**
-     * Superscript argument (`m:sup`).
-     */
-    superscript: MathArgument;
-}
-/**
- * Superscript structure (`m:sSup`) — a base with a superscript.
- *
- * Child sequence: `sSupPr?`, `e`, `sup`.
- *
- * @public
- */
-export declare class MathSuperscript extends MathElement {
-    /**
-     * Math element type for this control (`sSup`).
-     */
-    readonly type = "sSup";
-    private _properties;
-    private _base;
-    private _sup;
-    constructor(properties?: MathScriptControlProperties, base?: MathArgument | ReadonlyArray<MathElement>, sup?: MathArgument | ReadonlyArray<MathElement>);
-    /**
-     * Superscript configuration (`m:sSupPr`), such as script alignment.
-     */
-    properties: Readonly<MathScriptControlProperties>;
-    /**
-     * Base mathematical expression carrying the superscript (`m:e`).
-     */
-    base: MathArgument;
-    /**
-     * Superscript argument (`m:sup`).
-     */
-    superscript: MathArgument;
-}
-/**
- * Math run (`m:r`) — text and optional opaque WML run content inside an equation.
- *
- * Child sequence: `rPr?`, optional `w:rPr`, then (`m:t` | WML run content)*.
- * The constructor accepts a string (single {@link MathText}) or a children list.
- *
- * @public
- */
-export declare class MathRun extends MathElement {
-    /**
-     * Math element type for this control (`r`).
-     */
-    readonly type = "r";
-    private _properties;
-    private _wRPr;
-    private _children;
-    private _opaqueChildren;
-    constructor(textOrChildren?: string | ReadonlyArray<MathElement>, properties?: MathRunProperties, wRPr?: OpenXmlElement, opaqueChildren?: ReadonlyArray<OpenXmlElement>);
-    /**
-     * Math run configuration (`m:rPr`), such as literal/normal flags, script, and style.
-     */
-    properties: Readonly<MathRunProperties>;
-    /**
-     * Optional WordprocessingML run properties (`w:rPr`) nested under this math run.
-     *
-     * @private
-     * Opaque WML carrier for round-trip; not part of the public MathML authoring API.
-     */
-    /**
-    * @private
-    *
-    */
-    wRPr: OpenXmlElement | undefined;
-    /**
-     * Ordered math children of this run (typically {@link MathText} nodes).
-     */
-    readonly children: ReadonlyArray<MathElement>;
-    /**
-     * Opaque non-math WML run-content siblings preserved in order with math texts.
-     *
-     * @private
-     * Used by parse/serialize for round-trip fidelity; not part of the public authoring API.
-     */
-    readonly opaqueChildren: ReadonlyArray<OpenXmlElement>;
-    /**
-     * Replaces the ordered math children of this run.
-     */
-    setChildren(next: ReadonlyArray<MathElement>): void;
-    /**
-     * Concatenated text of all {@link MathText} children (full UTF-8 passthrough).
-     * Assigning a value replaces children with a single {@link MathText}.
-     */
-    text: string;
-}