@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

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

@@ -1,5 +1,5 @@
 import { IProperties } from '../type';
-import { IStyle } from '../style';
+import { ICellStyle } from '../style';
 import { ITable } from './ITable';
 export declare namespace ITableStyle {
     /**
@@ -56,13 +56,13 @@ export declare namespace ITableStyle {
     };
     type ElementType = typeof ElementType[keyof typeof ElementType];
     /**
-     * Extends {@link IStyle.Properties} to include a size.
+     * Extends {@link ICellStyle.Properties} to include a size.
      *
      * @remarks
      * This is used to allow for different styles depending on the number of stripes
      * (rows or columns used for the style).
      */
-    interface SizeBasedProperties extends IStyle.Properties {
+    interface SizeBasedProperties extends ICellStyle.Properties {
         /**
          * The size is available for the following table elements:
          * * firstRowStripe
@@ -115,7 +115,7 @@ export declare namespace ITableStyle {
         /**
          * Properties for the whole table.
          */
-        wholeTable?: IStyle.Properties;
+        wholeTable?: ICellStyle.Properties;
         /**
          * Properties for the first set of alternating columns.
          */
@@ -135,39 +135,39 @@ export declare namespace ITableStyle {
         /**
          * For the last column.
          */
-        lastColumn?: IStyle.Properties;
+        lastColumn?: ICellStyle.Properties;
         /**
          * For the first column.
          */
-        firstColumn?: IStyle.Properties;
+        firstColumn?: ICellStyle.Properties;
         /**
          * For the header row.
          */
-        headerRow?: IStyle.Properties;
+        headerRow?: ICellStyle.Properties;
         /**
          * For the first header cell. To be applied
          * both the header and first column must be selected.
          */
-        firstHeaderCell?: IStyle.Properties;
+        firstHeaderCell?: ICellStyle.Properties;
         /**
          * For the last header cell. To be applied
          * both the header and last column must be selected.
          */
-        lastHeaderCell?: IStyle.Properties;
+        lastHeaderCell?: ICellStyle.Properties;
         /**
          * For the total row.
          */
-        totalRow?: IStyle.Properties;
+        totalRow?: ICellStyle.Properties;
         /**
          * For the first total cell. To be applied
          * both the total and first column must be selected.
          */
-        firstTotalCell?: IStyle.Properties;
+        firstTotalCell?: ICellStyle.Properties;
         /**
          * For the last total cell. To be applied
          * both the total and last column must be selected.
          */
-        lastTotalCell?: IStyle.Properties;
+        lastTotalCell?: ICellStyle.Properties;
     }
     type ResolvableProperties = IProperties.ResolvableProperties<ITableStyle.Properties>;
     interface JSON extends ITableStyle.Properties {
@@ -188,31 +188,31 @@ export declare namespace ITableStyle {
      */
     interface PivotProperties {
         name?: string;
-        wholeTable?: IStyle.Properties;
+        wholeTable?: ICellStyle.Properties;
         firstColumnStripe?: ITableStyle.SizeBasedProperties;
         secondColumnStripe?: ITableStyle.SizeBasedProperties;
         firstRowStripe?: ITableStyle.SizeBasedProperties;
         secondRowStripe?: ITableStyle.SizeBasedProperties;
-        firstColumn?: IStyle.Properties;
-        headerRow?: IStyle.Properties;
-        firstHeaderCell?: IStyle.Properties;
-        pageFieldLabels?: IStyle.Properties;
-        pageFieldValues?: IStyle.Properties;
-        subtotalColumn1?: IStyle.Properties;
-        subtotalColumn2?: IStyle.Properties;
-        subtotalColumn3?: IStyle.Properties;
-        blankRow?: IStyle.Properties;
-        subtotalRow1?: IStyle.Properties;
-        subtotalRow2?: IStyle.Properties;
-        subtotalRow3?: IStyle.Properties;
-        columnSubheading1?: IStyle.Properties;
-        columnSubheading2?: IStyle.Properties;
-        columnSubheading3?: IStyle.Properties;
-        rowSubheading1?: IStyle.Properties;
-        rowSubheading2?: IStyle.Properties;
-        rowSubheading3?: IStyle.Properties;
-        grandTotalColumn?: IStyle.Properties;
-        grandTotalRow?: IStyle.Properties;
+        firstColumn?: ICellStyle.Properties;
+        headerRow?: ICellStyle.Properties;
+        firstHeaderCell?: ICellStyle.Properties;
+        pageFieldLabels?: ICellStyle.Properties;
+        pageFieldValues?: ICellStyle.Properties;
+        subtotalColumn1?: ICellStyle.Properties;
+        subtotalColumn2?: ICellStyle.Properties;
+        subtotalColumn3?: ICellStyle.Properties;
+        blankRow?: ICellStyle.Properties;
+        subtotalRow1?: ICellStyle.Properties;
+        subtotalRow2?: ICellStyle.Properties;
+        subtotalRow3?: ICellStyle.Properties;
+        columnSubheading1?: ICellStyle.Properties;
+        columnSubheading2?: ICellStyle.Properties;
+        columnSubheading3?: ICellStyle.Properties;
+        rowSubheading1?: ICellStyle.Properties;
+        rowSubheading2?: ICellStyle.Properties;
+        rowSubheading3?: ICellStyle.Properties;
+        grandTotalColumn?: ICellStyle.Properties;
+        grandTotalRow?: ICellStyle.Properties;
     }
 }
 /**
@@ -244,9 +244,9 @@ export interface ITableStyle {
      * Returns a ranged interface for applying this style to a specific table.
      *
      * @param table The target `ITable` to which this style will be applied.
-     * @returns An `ICellRanged` interface containing properties for `IStyle`.
+     * @returns An `ICellRanged` interface containing properties for `ICellStyle`.
      */
-    getRanged(table: ITable): IProperties.ICellRanged<IStyle.Properties>;
+    getRanged(table: ITable): IProperties.ICellRanged<ICellStyle.Properties>;
     /**
      * Indicates whether this style is a built-in, predefined style.
      *
@@ -294,7 +294,7 @@ export declare namespace ITableStyle {
      */
     class Empty implements ITableStyle {
         private _normalStyle;
-        constructor(normalStyle: IStyle);
+        constructor(normalStyle: ICellStyle);
         /** {@inheritDoc ITableStyle.getName} */
         getName(): string;
         /** {@inheritDoc ITableStyle.isShownInTableStyles} */
@@ -302,7 +302,7 @@ export declare namespace ITableStyle {
         /** {@inheritDoc ITableStyle.isShownInPivotStyles} */
         isShownInPivotStyles(): boolean;
         /** {@inheritDoc ITableStyle.getRanged} */
-        getRanged(_table: ITable): IProperties.ICellRanged<IStyle.Properties>;
+        getRanged(_table: ITable): IProperties.ICellRanged<ICellStyle.Properties>;
         /** {@inheritDoc ITableStyle.getProperties} */
         getProperties(): Readonly<ITableStyle.Properties>;
         /** {@inheritDoc ITableStyle.isBuiltIn} */

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

@@ -1,13 +1,14 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { INamed } from '../named';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
+import { ITransaction } from '../transaction';
 import { ITable } from './ITable';
 import { AbstractNamed } from '../named/AbstractNamed';
 export declare class NamedTable extends AbstractNamed<ITable, any> {
-    protected _sheet: ISheet;
+    protected _sheet: IWorksheet;
     protected _table: ITable;
-    constructor(sheet: ISheet, table: ITable, options: INamed.ConstructorOptions<ITable>);
+    constructor(sheet: IWorksheet, table: ITable, options: INamed.ConstructorOptions<ITable>);
     select(options?: ICellRange.SelectOptions): Promise<this>;
     getRanges(): ICellRanges | null;
     /**
@@ -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

@@ -1,7 +1,7 @@
 import { IListener } from '../listener';
 import { INamed } from '../named';
 import { NamedCollection } from '../named/NamedCollection';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 /**
  * Presents the tables of one or more sheets as named items.
  *
@@ -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;
@@ -46,7 +47,7 @@ export declare class NamedTableSource implements NamedCollection.Source {
 export declare namespace NamedTableSource {
     interface ConstructorOptions {
         /** The sheets whose tables are contributed. Re-read on every query. */
-        getSheets: () => readonly ISheet[];
+        getSheets: () => readonly IWorksheet[];
         /**
          * Subscribes to the sheet list changing, so tables on a sheet added later are picked up.
          * Omitted for a single, fixed sheet.

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';
@@ -32,22 +36,153 @@ export declare namespace IText {
     };
     type SmallCaps = typeof SmallCaps[keyof typeof SmallCaps];
     /**
-     * Indicate how and if a line will be drawing horizontally through the middle of the text.
+     * How a paragraph's text is aligned between its margins.
      */
-    const StrikeStyle: {
-        /**
-         * No strike-through
-         */
-        readonly None: "none";
-        /**
-         * A single line.
-         */
-        readonly Single: "single";
-        /**
-         * A double line.
-         */
-        readonly Double: "double";
+    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];
+    /**
+     * 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 text style has the same property ({@link IFontStyle.Properties}) the name and values
+     * are the same: `weight`, `style`, `underline`, `strike`, `letterSpacing`, `baseline`.
+     */
+    interface RunPropertiesJSON {
+        /** Font size in points. */
+        size?: number;
+        /** `700` for bold, `400` for regular. */
+        weight?: number;
+        style?: IFont.Style;
+        underline?: IFont.UnderlineStyle;
+        strike?: IFont.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;
     };
-    type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
+    /** 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