@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.10

package/types/src/table/TableCollection.d.ts

@@ -1,20 +1,31 @@
 import { ICellRange, ICellRanges } from '../cellRange';
+import { ICollection, AbstractCollection } from '../type';
+import { IListener } from '../listener';
 import { ITableCollection } from './ITableCollection';
 import { ITable } from './ITable';
-export declare class TableCollection implements ITableCollection {
+/**
+ * Implementation for {@link ITableCollection}.
+ *
+ * @remarks
+ * A front over the sheet's own table state — the sheet keeps the store and the events, this
+ * class keeps the API. `onCollectionChange` is the sheet's `onTablesChange`, forwarded with this
+ * collection as the source.
+ */
+export declare class TableCollection extends AbstractCollection<ITable, ITableCollection.GetItemsOptions> implements ITableCollection {
     private _add;
     private _get;
     private _getByName;
-    constructor(add: (address: ICellRange.Address, options: ITableCollection.AddOptions | boolean) => ITable, get: (address: ICellRanges.Address, ignoreHidden?: boolean, fullyContained?: boolean) => ITable[], getByName: (name: string) => ITable);
+    private _addListeners;
+    constructor(add: (address: ICellRange.Address, options: ITableCollection.AddOptions | boolean) => ITable, get: (address: ICellRanges.Address, ignoreHidden?: boolean, fullyContained?: boolean) => ITable[], getByName: (name: string) => ITable, addListeners: (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove);
     /** {@inheritDoc ITableCollection.add} */
     add(address: ICellRange.Address, options?: ITableCollection.AddOptions): ITable;
-    /** {@inheritDoc ICollection.[Symbol.iterator]} */
-    [Symbol.iterator](): IterableIterator<ITable>;
-    /** {@inheritDoc ITableCollection.getItems} */
-    getItems(options?: ITableCollection.GetItemsOptions): ITable[];
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: ITableCollection.GetItemsOptions): ITable[];
     /** {@inheritDoc ITableCollection.getByName} */
     getByName(name: string): ITable;
-    /** {@inheritDoc ITableCollection.getCount} */
-    getCount(): number;
+    /** {@inheritDoc ICollection.addListeners} */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc ITableCollection.isITableCollection} */
+    get isITableCollection(): true;
 }
 //# sourceMappingURL=TableCollection.d.ts.map

package/types/src/table/_FilterField.d.ts

@@ -1,3 +1,5 @@
+import { Scalar } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { ICellRange } from '../cellRange';
 import { ICondition } from '../condition';
@@ -9,22 +11,33 @@ export declare class FilterField implements IFilter {
     private _id;
     private _getProps;
     private _getColumnProps;
-    constructor(table: ITable, id: number | string, getProps: (id: number | string) => FilterPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState);
-    /** {@inheritDoc IFilter.Filterable.filter} */
-    filter(condition?: ICondition.Input | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * The sheet rows the table's filter levels hide, evaluated without the level on column
+     * `exceptIndex`; with every level when `null`.
+     */
+    private _getHiddenByLevels;
+    constructor(table: ITable, id: number | string, getProps: (id: number | string) => FilterPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState, getHiddenByLevels: (exceptIndex: number | null) => Promise<readonly RunCoords[]>);
+    /** {@inheritDoc IFilter.IFilterable.filter} */
+    filter(condition?: ICondition.Input | null, options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc IFilter.getCondition} */
     getCondition(): ICondition | null;
     /** {@inheritDoc IFilter.setCondition} */
-    setCondition(condition: ICondition.Input | null | undefined, append?: boolean, options?: ITransaction.OperationOptions): void;
+    setCondition(condition: ICondition.Input | null | undefined, replace?: boolean, options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc IFilter.apply} */
-    apply(): void;
+    apply(options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc IFilter.getIndex} */
     getIndex(): number;
     /** {@inheritDoc IFilter.getRange} */
     getRange(): ICellRange;
+    /** {@inheritDoc IFilter.getItems} */
+    getItems(options?: IFilter.GetItemsOptions): Promise<IFilter.Items>;
+    /** {@inheritDoc IFilter.getDisplayTexts} */
+    getDisplayTexts(values: readonly Scalar[]): readonly string[];
     /** {@inheritDoc IFilter.getLevel} */
     getLevel(): number;
     /** {@inheritDoc IFilter.delete} */
-    delete(options?: ITransaction.OperationOptions): void;
+    delete(options?: ITransaction.OperationOptions): Promise<this>;
+    /** {@inheritDoc IFilter.isIFilter} */
+    get isIFilter(): true;
 }
 //# sourceMappingURL=_FilterField.d.ts.map

package/types/src/table/_NamedTable.d.ts

@@ -2,6 +2,7 @@ import { IRange } from '@sheetxl/primitives';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { INamed } from '../named';
 import { ISheet } from '../sheet';
+import { ITransaction } from '../transaction';
 import { ITable } from './ITable';
 import { AbstractNamed } from '../named/AbstractNamed';
 export declare class NamedTable extends AbstractNamed<ITable, any> {
@@ -43,8 +44,14 @@ export declare class NamedTable extends AbstractNamed<ITable, any> {
      *
      * Only single-rectangle selections are answered, because only those have a spelling: a structured
      * reference names one contiguous region.
+     *
+     * Cells in `home`'s own data row are this-row references, whichever sheet `home` is on:
+     * `Sales[@Amount]` for one cell, `Sales[@[Qty]:[Cost]]` for adjacent ones and `Sales[@]` for the
+     * whole row. For a `home` cell
+     * inside this table, a single column drops the table name as Excel shows it: `[Amount]` for the
+     * column's data cells, `[@Amount]` for the one cell in `home`'s row.
      */
-    getPartReference(coords: readonly IRange.Coords[]): string | null;
+    getPartReference(coords: readonly IRange.Coords[], home?: IRange.CellCoords | null): string | null;
     /**
      * The item specifiers naming the rows `target` spans exactly, or `null` for a partial/oversized
      * one. Usually one (`['#Data']`); two for a band that is the union of two adjacent ones
@@ -79,6 +86,15 @@ export declare class NamedTable extends AbstractNamed<ITable, any> {
     getScope(): string;
     getType(): string;
     getName(): string;
+    /**
+     * {@inheritDoc INamed.setName}
+     *
+     * @remarks
+     * The table owns the name; this item only presents it. Delegated so that renaming through either
+     * handle is the same operation, rather than writing a name into this item's own state that
+     * {@link getName} never reads back.
+     */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
     getValue(): ITable;
 }
 //# sourceMappingURL=_NamedTable.d.ts.map

package/types/src/table/_NamedTableSource.d.ts

@@ -37,6 +37,7 @@ export declare class NamedTableSource implements NamedCollection.Source {
      */
     addListeners(listeners: {
         onCollectionChange?: (...args: any[]) => void;
+        onInvalidated?: (...args: any[]) => void;
     }, options?: IListener.Options): IListener.Remove;
     /** Re-points a subscription at the current sheets, if they have changed. */
     private _syncSubscription;

package/types/src/table/_SortField.d.ts

@@ -25,5 +25,7 @@ export declare class SortField implements ISort {
     getLevel(): number;
     /** {@inheritDoc ISort.delete} */
     delete(options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc ISort.isISort} */
+    get isISort(): true;
 }
 //# sourceMappingURL=_SortField.d.ts.map

package/types/src/table/_TableColumn.d.ts

@@ -3,14 +3,23 @@ import { ICellRange } from '../cellRange';
 import { ISort } from '../sort';
 import { IFilter } from '../filter';
 import { ITable } from './ITable';
-import { ColumnPropertiesState } from './_TableUtils';
+import { ColumnPropertiesState, ColumnTotals } from './_TableUtils';
 export declare class TableColumn implements ITable.IColumn {
     protected _table: ITable;
     protected _id: number | string;
     protected _getProps: (id: number | string) => ColumnPropertiesState;
     protected _updateProps: (id: number | string, update: Partial<ITable.ColumnProperties> | null, options?: string | ITransaction.OperationOptions) => void;
     protected _deleteSelf: (id: number | string, options?: ITransaction.OperationOptions) => void;
-    constructor(table: ITable, id: number | string, getProps: (id: number | string) => ColumnPropertiesState, updateProps: (id: number | string, update: Partial<ITable.ColumnProperties> | null, options?: string | ITransaction.OperationOptions) => void, deleteSelf: (id: number | string, options?: ITransaction.OperationOptions) => void);
+    protected _getTotals: ((id: number | string) => ColumnTotals) | undefined;
+    protected _getCalculated: ((id: number | string) => string | null) | undefined;
+    /**
+     * @param getTotals What the column's totals cell holds. A table whose totals row is on a sheet
+     * answers from the cell; without this the column props are all there is.
+     * @param getCalculated The column's calculated formula as the engine has it now; without this
+     * the column props are all there is.
+     */
+    constructor(table: ITable, id: number | string, getProps: (id: number | string) => ColumnPropertiesState, updateProps: (id: number | string, update: Partial<ITable.ColumnProperties> | null, options?: string | ITransaction.OperationOptions) => void, deleteSelf: (id: number | string, options?: ITransaction.OperationOptions) => void, getTotals?: (id: number | string) => ColumnTotals, getCalculated?: (id: number | string) => string | null);
+    private _totals;
     /** {@inheritDoc ITable.IColumn.getTable} */
     getTable(): ITable;
     /** {@inheritDoc ITable.IColumn.getName} */
@@ -29,6 +38,8 @@ export declare class TableColumn implements ITable.IColumn {
     setTotalsRowFormula(formula: string | number | undefined): this;
     /** {@inheritDoc ITable.IColumn.getTotalsRowFormula} */
     getTotalsRowFormula(): string | number | null;
+    /** {@inheritDoc ITable.IColumn.getCalculatedFormula} */
+    getCalculatedFormula(): string | null;
     /** {@inheritDoc ITable.IColumn.getSort} */
     getSort(): ISort | null;
     /** {@inheritDoc ITable.IColumn.getFilter} */

package/types/src/table/_TableMessages.d.ts

@@ -2,4 +2,5 @@ export declare const MODEL_DELETED = "Table has been deleted. No further operati
 export declare const MODEL_CLOSED = "Table has been closed. No further operations are allowed.";
 export declare const ERROR_GET_BY_NAME = "Get by name must take a valid name.";
 export declare const ERROR_TABLE_COLUMN_ID_IMMUTABLE = "Table column ID is immutable and can not be changed.";
+export declare const ERROR_NO_SHEET = "Table is not on a sheet. A preview table has no cells to operate on.";
 //# sourceMappingURL=_TableMessages.d.ts.map

package/types/src/table/_TableUtils.d.ts

@@ -20,9 +20,49 @@ export declare function defaultAutoTableName(): string;
 export declare function defaultAutoTableDescription(): string;
 export type ColumnNamer = (name: string, index: number) => string;
 export declare function DefaultColumnNamer(name: string, index: number): string;
+/**
+ * The case-insensitive key a column name is deduplicated by. Not trimmed: Excel keeps ` `, `a ` and
+ * `a` as three distinct columns, and only an empty name is blank.
+ */
 export declare function toKey(name: string | null | undefined): string | null;
 export declare function deserializeRef(ref?: IRange.Coords | any): IRange.Coords;
 export declare const DefaultStyleOptions: ITableStyle.StyleOptions;
+/**
+ * What a column's totals cell shows: a label, a formula, or nothing. Never both - a cell is one
+ * thing.
+ */
+export type ColumnTotals = Pick<ITable.ColumnProperties, 'totalsRowLabel' | 'totalsRowFormula'>;
+/** Whether `value` is a `SUBTOTAL` function number a totals row can hold (`101` to `110`). */
+export declare function isTotalsFunctionNumber(value: unknown): value is number;
+/**
+ * A totals formula as the table holds it: a `SUBTOTAL` function number, or an expression in
+ * storage form without the leading `=`. `undefined` when there is none.
+ *
+ * @remarks
+ * Input arrives three ways - a number, an expression, and the function NAME a file uses (`'sum'`).
+ * A name becomes its number, so nothing past this point has to know the names exist.
+ */
+export declare function normalizeTotalsRowFormula(value: string | number | null | undefined): string | number | undefined;
+/**
+ * A column as a structured reference spells it, without the brackets: `[`, `]`, `#` and `'` each
+ * escaped with a leading `'`, as Excel spells them.
+ */
+export declare function columnSpecifier(name: string): string;
+/**
+ * The expression a totals function number stands for, in the column it totals.
+ *
+ * @remarks
+ * The bare `[Column]` form, as it is typed into a totals cell. It binds to the table the cell is
+ * in, so it can only be written once the sheet has that table.
+ */
+export declare function totalsFunctionExpression(functionNum: number, columnName: string): string;
+/**
+ * The function number a totals expression is the built-in form of - `SUBTOTAL(10x,` this column
+ * `)` - or `null` for anything else.
+ *
+ * @param expression Storage or display form; the column may be qualified by its table or not.
+ */
+export declare function asTotalsFunctionNumber(expression: string, tableName: string, columnName: string): number | null;
 /**
  * Faster solution for normalize columns when empty.
  */

package/types/src/text/Bullet.d.ts

@@ -10,6 +10,8 @@ export interface IBullet {
     readonly imageNaturalWidth: number;
     readonly imageNaturalHeight: number;
     readonly bounds?: Bounds;
+    /** For runtime type checking. */
+    readonly isIBullet: true;
 }
 export declare class DefaultBullet implements IBullet {
     private _fontName;
@@ -30,5 +32,7 @@ export declare class DefaultBullet implements IBullet {
     get imageNaturalWidth(): number;
     get imageNaturalHeight(): number;
     get bounds(): Bounds | undefined;
+    /** {@inheritDoc IBullet.isIBullet} */
+    get isIBullet(): true;
 }
 //# sourceMappingURL=Bullet.d.ts.map

package/types/src/text/IText.d.ts

@@ -1,3 +1,7 @@
+import { IFont } from '../font';
+import { IFill, IStroke, IEffect } from '../fill';
+import { IHyperlink } from '../hyperlink';
+import { ITextFrame } from './ITextFrame';
 import { ITextLine as _ITextLine } from './TextLine';
 import { ITextParagraph as _ITextParagraph } from './TextParagraph';
 import { ITextRun as _ITextRun } from './TextRun';
@@ -49,5 +53,183 @@ export declare namespace IText {
         readonly Double: "double";
     };
     type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
+    /**
+     * How a paragraph's text is aligned between its margins.
+     */
+    const ParagraphAlignment: {
+        readonly Left: "left";
+        readonly Center: "center";
+        readonly Right: "right";
+        /** Spread to both margins, the last line excepted. */
+        readonly Justify: "justify";
+        /** Justified with a low kashida, for Arabic text. */
+        readonly JustifyLow: "justifyLow";
+        /** Every line, the last included, is spread to both margins. */
+        readonly Distributed: "distributed";
+        /** Distributed the way Thai text is. */
+        readonly ThaiDistributed: "thaiDistributed";
+    };
+    type ParagraphAlignment = typeof ParagraphAlignment[keyof typeof ParagraphAlignment];
+    /**
+     * Where runs of different sizes sit on a line.
+     */
+    const FontAlignment: {
+        readonly Auto: "auto";
+        readonly Top: "top";
+        readonly Center: "center";
+        readonly Baseline: "baseline";
+        readonly Bottom: "bottom";
+    };
+    type FontAlignment = typeof FontAlignment[keyof typeof FontAlignment];
+    /**
+     * How a run of drawing text is underlined.
+     *
+     * @remarks
+     * Drawing text has more underlines than a cell's font ({@link IFont.UnderlineStyle}); the two
+     * agree on `none`, `single` and `double`.
+     */
+    const UnderlineStyle: {
+        readonly None: "none";
+        /** Each word underlined, the spaces between them not. */
+        readonly Words: "words";
+        readonly Single: "single";
+        readonly Double: "double";
+        readonly Heavy: "heavy";
+        readonly Dotted: "dotted";
+        readonly DottedHeavy: "dottedHeavy";
+        readonly Dash: "dash";
+        readonly DashHeavy: "dashHeavy";
+        readonly DashLong: "dashLong";
+        readonly DashLongHeavy: "dashLongHeavy";
+        readonly DotDash: "dotDash";
+        readonly DotDashHeavy: "dotDashHeavy";
+        readonly DotDotDash: "dotDotDash";
+        readonly DotDotDashHeavy: "dotDotDashHeavy";
+        readonly Wavy: "wavy";
+        readonly WavyHeavy: "wavyHeavy";
+        readonly WavyDouble: "wavyDouble";
+    };
+    type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
+    /**
+     * A font named by a run: a family, or one of the theme's two fonts.
+     */
+    interface FontJSON {
+        family?: string;
+        /** The theme's heading (`major`) or body (`minor`) font, in place of a family. */
+        scheme?: IFont.Scheme;
+        /** PANOSE classification as the file states it (ten hex bytes). */
+        panose?: string;
+        /** A family to fall back to, derived from `panose` when read. */
+        fallbacks?: string[];
+        pitch?: string;
+        charset?: IFont.Charset;
+    }
+    /**
+     * How a run is formatted. Sizes are in points, `baseline` is a percentage of the size (`30`
+     * raises the run as a superscript), colors are fills or serialized colors.
+     *
+     * @remarks
+     * Where a cell's font has the same property ({@link IStyledFont.Properties}) the name and
+     * values are the same: `weight`, `style`, `letterSpacing`, `family`.
+     */
+    interface RunPropertiesJSON {
+        /** Font size in points. */
+        size?: number;
+        /** `700` for bold, `400` for regular. */
+        weight?: number;
+        style?: IFont.Style;
+        underline?: UnderlineStyle;
+        strike?: StrikeStyle;
+        /** The text color: a fill (solid, gradient, pattern) or a serialized color. */
+        color?: IFill.JSON | string;
+        /** The Latin font. */
+        font?: FontJSON;
+        eastAsianFont?: FontJSON;
+        complexScriptFont?: FontJSON;
+        symbolFont?: FontJSON;
+        /** Language tag (`en-US`). */
+        language?: string;
+        alternateLanguage?: string;
+        /** Kerning threshold in points. */
+        kerning?: number;
+        /** Character spacing in points. */
+        letterSpacing?: number;
+        /** Baseline shift as a percentage of the font size; positive raises. */
+        baseline?: number;
+        capitals?: SmallCaps;
+        normalizeHeight?: boolean;
+        /** Highlight color, serialized. */
+        highlight?: string;
+        hyperlink?: IHyperlink.JSON;
+        /** The text outline. */
+        outline?: IStroke.JSON;
+        effects?: IEffect.JSON[];
+    }
+    /** A run of text. */
+    interface RunJSON extends RunPropertiesJSON {
+        /** The run's text; `'\n'` alone is a line break inside the paragraph. */
+        text: string;
+        /** Set when the run is a field (`fld`): its id and kind (`TxLink`, `slidenum`…). */
+        field?: {
+            id: string;
+            type?: string;
+        };
+    }
+    /** A spacing: in points, or as a percentage of a line (`100` is single spacing). */
+    type SpacingJSON = {
+        points: number;
+    } | {
+        percent: number;
+    };
+    /** A paragraph's bullet. Without a `type` the entry only restyles the inherited bullet. */
+    interface BulletJSON {
+        type?: 'none' | 'char' | 'auto' | 'image';
+        /** The character of a `char` bullet. */
+        char?: string;
+        /** The numbering scheme of an `auto` bullet (`arabicPeriod`, `romanLcParenR`…). */
+        autoType?: string;
+        startAt?: number;
+        font?: FontJSON;
+        fontFollowsText?: boolean;
+        /** Serialized color. */
+        color?: string;
+        colorFollowsText?: boolean;
+        size?: SpacingJSON;
+        sizeFollowsText?: boolean;
+    }
+    interface TabJSON {
+        /** Position in pixels. */
+        position: number;
+        align?: ITextFrame.TabStopAlignment;
+    }
+    /** How a paragraph is laid out. Lengths are in pixels. */
+    interface ParagraphPropertiesJSON {
+        align?: ParagraphAlignment;
+        /** Outline level, `0` to `8`. */
+        level?: number;
+        marginLeft?: number;
+        marginRight?: number;
+        /** First-line indent; negative for a hanging indent. */
+        indent?: number;
+        defaultTabSize?: number;
+        rightToLeft?: boolean;
+        eastAsianLineBreak?: boolean;
+        latinLineBreak?: boolean;
+        hangingPunctuation?: boolean;
+        fontAlign?: FontAlignment;
+        lineSpacing?: SpacingJSON;
+        spaceBefore?: SpacingJSON;
+        spaceAfter?: SpacingJSON;
+        bullet?: BulletJSON;
+        tabs?: TabJSON[];
+        /** The run formatting the paragraph's runs inherit. */
+        defaultRun?: RunPropertiesJSON;
+    }
+    /** A paragraph: runs in order, and how it is laid out. */
+    interface ParagraphJSON extends ParagraphPropertiesJSON {
+        runs: RunJSON[];
+        /** The formatting of the paragraph mark (what a new run at its end takes). */
+        endRun?: RunPropertiesJSON;
+    }
 }
 //# sourceMappingURL=IText.d.ts.map

package/types/src/text/ITextFrame.d.ts

@@ -4,13 +4,14 @@ import { TextVisitor } from './TextVisitor';
 import { ITextLine } from './TextLine';
 import { ITextParagraph } from './TextParagraph';
 import { ITextBoxAlignment as _IAlignment } from './TextBoxAlignment';
+import { IText } from './IText';
 /**
  * Represents a rectangular container for text and its formatting within a document.
  *
  * A TextFrame allows precise control over the positioning, size (width and height),
  * layout, and appearance of text content.
  */
-export interface ITextFrame {
+export interface ITextFrame extends ITextFrame.IText {
     readonly wrapped: boolean;
     readonly insets: Rectangle;
     readonly orientation: ITextFrame.Orientation;
@@ -57,6 +58,8 @@ export interface ITextFrame {
      * @param allowWrap If `true` then will try to wrap on natural breaks. Defaults the the current settings.
      */
     createTextFrame(text: string, allowWrap?: boolean): ITextFrame;
+    /** For runtime type checking. */
+    readonly isITextFrame: true;
 }
 /**
  * {@inheritDoc ITextFrame}
@@ -66,6 +69,28 @@ export interface ITextFrame {
  * {@link ITextFrame}
  */
 export declare namespace ITextFrame {
+    /**
+     * The text of a frame, without its layout.
+     *
+     * @remarks
+     * What a frame can always answer, including one whose layout is not modeled — text on an
+     * imported shape is read this way.
+     */
+    interface IText {
+        /**
+         * Returns the frame's text with its formatting stripped.
+         *
+         * @remarks
+         * - Paragraphs are separated by `
+    `, and a line break inside a paragraph is also `
+    `.
+         * - Runs and fields are concatenated in document order.
+         * - Blank paragraphs at the start and end are dropped; blank paragraphs between text are kept.
+         * - An equation reads as its linear text form.
+         * - A frame with nothing written in it answers `''`.
+         */
+        getText(): string;
+    }
     namespace IAlignment {
         type Properties = _IAlignment.Properties;
         type JSON = _IAlignment.JSON;
@@ -299,8 +324,92 @@ export declare namespace ITextFrame {
          * Centers text at the tab stop.
          */
         readonly Center: "center";
+        /**
+         * Aligns numbers at the tab stop on their decimal point.
+         */
+        readonly Decimal: "decimal";
     };
     type TabStopAlignment = typeof TabStopAlignment[keyof typeof TabStopAlignment];
+    /**
+     * The direction drawing text runs in its body.
+     */
+    const WritingMode: {
+        readonly Horizontal: "horizontal";
+        /** Each line turned 90° clockwise, read top to bottom; lines advance leftwards. */
+        readonly Vertical: "vertical";
+        /** Each line turned 270° clockwise, read bottom to top; lines advance rightwards. */
+        readonly Vertical270: "vertical270";
+        /** WordArt vertical: upright letters stacked top to bottom. */
+        readonly WordArtVertical: "wordArtVertical";
+        /** East Asian vertical: upright ideographs, Latin text turned. */
+        readonly EastAsianVertical: "eastAsianVertical";
+        /** Mongolian vertical: top to bottom, lines advancing rightwards. */
+        readonly MongolianVertical: "mongolianVertical";
+        /** WordArt vertical read right to left. */
+        readonly WordArtVerticalRtl: "wordArtVerticalRtl";
+    };
+    type WritingMode = typeof WritingMode[keyof typeof WritingMode];
+    /** Text insets from the text rectangle, in pixels. */
+    interface InsetsJSON {
+        left?: number;
+        top?: number;
+        right?: number;
+        bottom?: number;
+    }
+    /** How a text body sits in the frame that holds it. */
+    interface BodyJSON {
+        /** Vertical anchor of the text in the frame. */
+        anchor?: VerticalAlignment;
+        /** Center the text box horizontally within the frame. */
+        anchorCenter?: boolean;
+        wrap?: 'none' | 'square';
+        insets?: InsetsJSON;
+        /** `shape` grows the frame to fit the text; `normal` shrinks the text to fit the frame. */
+        autoFit?: Autofit;
+        /** With `normal` autofit: the font scale applied, as a percentage. */
+        fontScale?: number;
+        /** With `normal` autofit: the line spacing reduction applied, as a percentage. */
+        lineSpacingReduction?: number;
+        vertical?: WritingMode;
+        /** What happens to text past the bottom: `visible`, `ellipsis` or `clip`. */
+        verticalOverflow?: Overflow;
+        /** What happens to text past the sides: `visible` or `clip`. */
+        horizontalOverflow?: Overflow;
+        upright?: boolean;
+        rightToLeftColumns?: boolean;
+        columns?: number;
+        /** Space between columns, in pixels. */
+        columnSpacing?: number;
+        fromWordArt?: boolean;
+        forceAntiAlias?: boolean;
+        compatibleLineSpacing?: boolean;
+        spaceFirstLastParagraph?: boolean;
+        /** A preset text warp (`prstTxWarp`) and its adjust values, in the preset grammar's units. */
+        warp?: {
+            preset: string;
+            adjustments?: Record<string, number>;
+        };
+        /** `bodyPr/extLst` as the file states it: an opaque DrawingML fragment, written back as it was. */
+        extLst?: string;
+    }
+    /** The paragraph formatting a text body's levels inherit (`lstStyle`). */
+    interface ListStyleJSON {
+        default?: IText.ParagraphPropertiesJSON;
+        /** Levels 1 to 9, by index; a level the file does not state is absent. */
+        levels?: (IText.ParagraphPropertiesJSON | undefined)[];
+    }
+    /**
+     * The text written in a frame — a shape's text body — as JSON: its paragraphs, how the body
+     * sits in the frame, and the list style the paragraphs inherit from.
+     */
+    interface JSON {
+        paragraphs: IText.ParagraphJSON[];
+        /** Text rotation in degrees, when the body states one. */
+        rotation?: number;
+        /** How the body sits in the frame; absent for the defaults. */
+        body?: BodyJSON;
+        listStyle?: ListStyleJSON;
+    }
     interface CloneableTextFrame extends ITextFrame {
         clone(visitor?: TextVisitor): ITextFrame;
         equals(other: ITextFrame): boolean;