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

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

@@ -29,11 +29,7 @@ export declare class AutoTable extends AnchoredTable {
     protected _initialize(options: AnchoredTable.ConstructorOptions): void;
     protected initializeColumnCreator(table: ITable, getProps: (id: number | string) => ColumnPropertiesState, updateProps: (id: number | string, update: Partial<ITable.ColumnProperties> | null, options?: string | ITransaction.OperationOptions) => void, deleteColumn: (id: number | string, options?: ITransaction.OperationOptions) => void): (id: number | string) => ITable.IColumn;
     protected _processHeaderListener(): void;
-    protected _readSyncSheet(ignoreBlanks?: boolean): {
-        columns: ITable.ColumnProperties[];
-        converted: boolean;
-    } | null;
-    protected _writeSyncSheet(isRemove?: boolean): void;
+    protected _syncHeader(): void;
     protected _calcVisible(): void;
     isShowHeaders(): boolean;
     addRows(index: number, count?: number, options?: ITransaction.OperationOptions): this;
@@ -41,6 +37,10 @@ export declare class AutoTable extends AnchoredTable {
     deleteRowsAt(index: number, count?: number, options?: ITransaction.OperationOptions): this;
     getColumnByName(name: string): ITable.IColumn | null;
     convertToRange(maxCells?: number, options?: ITransaction.OperationOptions): ICellRange;
+    /**
+     * Removes the AutoFilter. Its cells are the sheet's data and are left as they are.
+     */
+    delete(_options?: ITransaction.OperationOptions): void;
     setName(name: string, options?: ITransaction.OperationOptions): this;
     setDescription(description: string, options?: ITransaction.OperationOptions): this;
     updateStyleOptions(options: ITableStyle.StyleOptions, description?: string): this;

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

@@ -36,6 +36,59 @@ import { ITableStyle } from './ITableStyle';
  * * {@link ITableCollection}
  */
 export declare namespace ITable {
+    /**
+     * Which edges of a table grow when something is entered just beside it.
+     *
+     * @remarks
+     * A value entered in the column just right of the table makes a new column, and one entered in
+     * the row just below it makes a new row (or, for a formula, a totals row - see
+     * {@link ITable.FormulaBelow}). The table only grows over cells that are otherwise blank.
+     *
+     * Growing down also lets Tab from the last cell of the body add a row; without it, Tab wraps to
+     * the first cell of the body.
+     */
+    const AutoExpand: {
+        /**
+         * Grow right and down. The default.
+         */
+        readonly Both: "both";
+        /**
+         * Grow down only.
+         */
+        readonly Rows: "rows";
+        /**
+         * Grow right only.
+         */
+        readonly Columns: "columns";
+        /**
+         * Never grow.
+         */
+        readonly None: "none";
+    };
+    type AutoExpand = typeof AutoExpand[keyof typeof AutoExpand];
+    /**
+     * Where a formula entered in the row just below a table goes, when the table has no totals row
+     * showing and grows down (see {@link ITable.AutoExpand}).
+     *
+     * @remarks
+     * A value that is not a formula always makes a new row.
+     */
+    const FormulaBelow: {
+        /**
+         * The row becomes the table's totals row, and the formula its column's total. The other columns
+         * total nothing, unless the table held totals from a totals row shown earlier. The default.
+         */
+        readonly TotalsRow: "totalsRow";
+        /**
+         * The row becomes a row of the table, as a value would.
+         */
+        readonly InsideTable: "insideTable";
+        /**
+         * The formula stays below the table, which does not grow.
+         */
+        readonly BelowTable: "belowTable";
+    };
+    type FormulaBelow = typeof FormulaBelow[keyof typeof FormulaBelow];
     /**
      * Returns a column for the table.
      */
@@ -63,27 +116,75 @@ export declare namespace ITable {
          */
         getIndex(): number;
         /**
-         * A string representing a label in the totals row for the given column.
+         * Sets the text shown in the totals row for this column.
+         *
+         * @param label The text, or an empty string for none.
+         *
+         * @remarks
+         * A totals cell shows a label or a formula, never both: setting a label removes the column's
+         * totals formula. While the totals row is hidden the label is kept, and shown with the row.
          */
         setTotalsRowLabel(label: string): this;
         /**
-         * Returns a string representing a label in the totals row for the given column.
+         * Returns the text shown in the totals row for this column.
          *
          * @returns The label or `null` if there is none.
+         *
+         * @remarks
+         * While the totals row is shown this is what its cell holds, so text typed into the cell is
+         * the label.
          */
         getTotalsRowLabel(): string | null;
         /**
-         * This is either a number or a string.
+         * Sets what this column totals.
+         *
+         * @param formula A `SUBTOTAL` function number (`101` to `110`; `109` is sum, `101` average,
+         * `103` count), a formula with or without the leading `=`, or `undefined` for none. A function
+         * number totals this column: `109` is `=SUBTOTAL(109,[Column])`.
          *
          * @remarks
-         * If this is a custom formula then this is a string if it is a number then
-         * is is treated as the functionNum param to the SUBTOTAL function.
+         * A totals cell shows a label or a formula, never both: setting a formula removes the column's
+         * totals label. While the totals row is hidden the formula is kept, and shown with the row.
+         *
+         * @example
+         * ```ts
+         * table.setShowTotals(true);
+         * table.getColumnByName('Amount').setTotalsRowFormula(109);
+         * table.getColumnByName('Price').setTotalsRowFormula('=MAX([Price])-MIN([Price])');
+         * ```
          */
         setTotalsRowFormula(formula: string | number | undefined): this;
         /**
-         * Returns this is either a number or a string.
+         * Returns what this column totals.
+         *
+         * @returns A `SUBTOTAL` function number when the column is totaled by one over itself, the
+         * formula without its leading `=` for anything else, or `null` if there is none.
+         *
+         * @remarks
+         * While the totals row is shown this is what its cell holds, so a formula typed into the cell
+         * is returned here, and `=SUBTOTAL(109,[Column])` typed into it returns `109`.
          */
         getTotalsRowFormula(): string | number | null;
+        /**
+         * Returns the formula this column calculates its rows with.
+         *
+         * @returns The formula without its leading `=`, as it reads in the column's first body row, or
+         * `null` if this is not a calculated column.
+         *
+         * @remarks
+         * A column becomes calculated when a formula is entered into one of its cells and the rest of
+         * the column is empty: the formula is filled down the column, and every row added to the
+         * table afterwards is given it too. Entering a different formula into a calculated column
+         * replaces it for the whole column, unless the column already holds a cell that differs.
+         *
+         * @example
+         * ```ts
+         * sheet.getRange('D2').setFormula('=[@Price]*[@Qty]');
+         * // once the column has filled
+         * table.getColumnByName('Total').getCalculatedFormula(); // '[@Price]*[@Qty]'
+         * ```
+         */
+        getCalculatedFormula(): string | null;
         /**
          * Returns the sort field for this column.
          */
@@ -140,17 +241,24 @@ export declare namespace ITable {
          */
         id?: string;
         /**
-         * A string representing a label in the totals row for the given column.
+         * The text shown in the totals row for this column. A column with a
+         * {@link totalsRowFormula} shows that instead.
          */
         totalsRowLabel?: string;
         /**
-         * This is either a number or a string.
+         * What this column totals: a `SUBTOTAL` function number (`101` to `110`; `109` is sum) that
+         * totals this column, or a formula without its leading `=`.
          *
-         * @remarks
-         * If this is a custom formula then this is a string if it is a number then
-         * is is treated as the functionNum param to the SUBTOTAL function.
+         * @see {@link ITable.IColumn.setTotalsRowFormula}
          */
         totalsRowFormula?: string | number;
+        /**
+         * The formula a calculated column gives its rows, without its leading `=`, as it reads in the
+         * column's first body row.
+         *
+         * @see {@link ITable.IColumn.getCalculatedFormula}
+         */
+        calculatedColumnFormula?: string;
     }
     /**
      * A set of values that can be set on a ITable.
@@ -193,15 +301,38 @@ export declare namespace ITable {
          * @defaultValue 0
          */
         totalsRowCount?: number;
+        /**
+         * Whether the table has ever shown a totals row.
+         *
+         * @remarks
+         * The first time a totals row is shown the last column is given a total - a sum when the
+         * column holds only numbers, a count otherwise. A table that has already shown one keeps
+         * whatever its columns had when the row was hidden, including nothing.
+         *
+         * @defaultValue false
+         */
+        totalsRowShown?: boolean;
         /**
          * If not specified then the default table style is used
          * If the style name isn't valid then uses a 'none' style.
          */
         style?: ITableStyle.StyleOptions | string;
         /**
-         * If true the table will not auto expand.
+         * Which edges of the table grow when something is entered just beside it.
+         *
+         * @defaultValue {@link ITable.AutoExpand.Both}
          */
-        disabledAutoExpand?: boolean;
+        autoExpand?: ITable.AutoExpand;
+        /**
+         * Where a formula entered in the row just below the table goes.
+         *
+         * @defaultValue {@link ITable.FormulaBelow.TotalsRow}
+         */
+        formulaBelow?: ITable.FormulaBelow;
+        /**
+         * If true a formula entered into a column is not filled down it.
+         */
+        disabledColumnFill?: boolean;
         /**
          * A unique id for all tables in the workbook.
          *
@@ -322,6 +453,9 @@ export interface ITable extends IAnchored {
     /**
      * Add a single row to the table.
      *
+     * @param index The body row the new row goes in before, `0` being the first. Omitted, the row
+     * is added at the end.
+     *
      * @remarks
      * This is a convenience method for {@link addRows(index, 1)}
      */
@@ -329,11 +463,19 @@ export interface ITable extends IAnchored {
     /**
      * Add a number of rows to a table.
      *
+     * @param index The body row the new rows go in before, `0` being the first. An index at or past
+     * the number of body rows adds them at the end, above the totals row if there is one.
+     * @param count The number of rows to add. Defaults to `1`.
+     *
      * @remarks
-     * Not implemented
+     * The rows are inserted across the table's columns only: cells below the table move down, and
+     * cells beside it stay where they are. A calculated column gives the new rows its formula.
      *
-     * @param index
-     * @param count
+     * @example
+     * ```ts
+     * table.addRows(0, 2); // two rows at the top of the body
+     * table.addRow();      // one at the end
+     * ```
      */
     addRows(index: number, count?: number, options?: ITransaction.OperationOptions): ITable;
     /**
@@ -386,6 +528,15 @@ export interface ITable extends IAnchored {
      * @returns The column or `null` if not found.
      */
     getColumnAt(index: number): ITable.IColumn | null;
+    /**
+     * Deletes the table and clears its cells.
+     *
+     * @remarks
+     * A formula that references the table has each reference replaced by `#REF!`.
+     *
+     * @see {@link ITable.convertToRange} to remove the table and keep its cells.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * Convert the existing table to a range.
      * This will remove the table but preserve the original
@@ -395,6 +546,9 @@ export interface ITable extends IAnchored {
      *
      * @remarks
      * This can be an expensive operation.
+     *
+     * A formula that references the table has each reference replaced by the absolute address it
+     * designated (`Sheet1!$A$2:$C$4`).
      */
     convertToRange(maxCells?: number, options?: ITransaction.OperationOptions): ICellRange;
     /**
@@ -556,13 +710,42 @@ export interface ITable extends IAnchored {
      */
     setShowBandedRows(showBandedRows: boolean, options?: ITransaction.OperationOptions): this;
     /**
-     * If true the table will not auto expand.
+     * Set which edges of the table grow when something is entered just beside it.
+     *
+     * @remarks
+     * The growth is its own step, so the first undo takes back the growth and keeps what was entered.
+     */
+    setAutoExpand(autoExpand: ITable.AutoExpand, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns which edges of the table grow when something is entered just beside it.
+     */
+    getAutoExpand(): ITable.AutoExpand;
+    /**
+     * Set where a formula entered in the row just below the table goes.
+     *
+     * @example
+     * ```ts
+     * // formulas typed under the table become new rows, as values do
+     * table.setFormulaBelow(ITable.FormulaBelow.InsideTable);
+     * ```
+     */
+    setFormulaBelow(formulaBelow: ITable.FormulaBelow, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns where a formula entered in the row just below the table goes.
+     */
+    getFormulaBelow(): ITable.FormulaBelow;
+    /**
+     * If true a formula entered into one cell of an empty column is not filled down the column.
+     *
+     * @remarks
+     * A column that is already calculated keeps its formula, and rows added to the table are still
+     * given it.
      */
-    setDisabledAutoExpand(disabledAutoSize: boolean, options?: ITransaction.OperationOptions): this;
+    setDisabledColumnFill(disabledColumnFill: boolean, options?: ITransaction.OperationOptions): this;
     /**
-     * Returns if the table is set to not auto expand.
+     * Returns if the table is set to not fill a formula down its column.
      */
-    isDisabledAutoExpand(): boolean;
+    isDisabledColumnFill(): boolean;
     /**
      * Returns the bounds for the ref accounting for hidden headers.
      *
@@ -600,16 +783,19 @@ export interface ITable extends IAnchored {
      */
     getSnapshot(options?: ReferenceableClipboard.CopyOptions): ITable.ISnapshot;
     /**
-     * Applied all filters using the existing criteria.
+     * Applies all filters using the existing criteria.
      *
      * @remarks
      * Does not change criteria; only recomputes which rows are visible.
+     *
+     * @returns Resolves once the rows are hidden; one transaction, one undo step.
      */
-    applyFilters(options?: ITransaction.OperationOptions): this;
+    applyFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /**
-     * Clears all filters.
+     * Clears all filters and shows every row of the table, as Excel's Clear does — a row hidden by
+     * hand inside the table comes back too. The header and totals rows are never touched.
      */
-    deleteFilters(options?: ITransaction.OperationOptions): this;
+    deleteFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /**
      * Returns the active filter entries as handle objects,
      */
@@ -619,9 +805,21 @@ export interface ITable extends IAnchored {
      */
     getFilterAt(index: number): IFilter | null;
     /**
-     * Perform filtering on the table.
+     * Replaces the filter levels and hides the rows that fail them.
+     *
+     * @param conditions
+     * - `undefined` or `{ conditions: [] }` → clears every filter, as {@link deleteFilters}.
+     * - a bare `ICondition.Input` → one filter on the first column, as `ICellRange.filter`.
+     * - `{ conditions: [...] }` → one level per condition, on the column each `index` names
+     *   (its position in the array when omitted), in that order.
+     *
+     * @remarks
+     * Every row the table holds is judged, whatever hid it before (`includeHidden` defaults to
+     * `true` for a filter); the header and totals rows are never evaluated or hidden.
+     *
+     * @returns Resolves once the rows are hidden; one transaction, one undo step.
      */
-    filter(conditions?: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): this;
+    filter(conditions?: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<this>;
     /**
      * Replaces the sort chain.
      *
@@ -658,13 +856,13 @@ export interface ITable extends IAnchored {
      */
     getActiveSorts(): readonly ISort[];
     /**
-     * Applies both applySorts and applyFilters.
+     * Applies both applyFilters and applySorts, in that order, as one transaction.
      */
-    applySortsAndFilters(options?: ITransaction.OperationOptions): this;
+    applySortsAndFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /**
-     * Deletes both sorts and filters.
+     * Deletes both sorts and filters as one transaction.
      */
-    deleteSortsAndFilters(options?: ITransaction.OperationOptions): this;
+    deleteSortsAndFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /**
      * Sets whether the filter/sort button at the specified index is hidden.
      */

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

@@ -28,6 +28,8 @@ export interface ITableCollection extends ICollection<ITable> {
      * @param name The name to filter for This is case insensitive.
      */
     getByName(name: string): ITable | null;
+    /** For runtime type checking. */
+    readonly isITableCollection: true;
 }
 /**
  * {@inheritDoc ITableCollection}

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

@@ -10,14 +10,14 @@ export declare class FilterField implements IFilter {
     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;
+    /** {@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} */
@@ -25,6 +25,8 @@ export declare class FilterField implements IFilter {
     /** {@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