@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

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

@@ -0,0 +1,88 @@
+import { ITransaction } from '../transaction';
+import { ICollection } from '../type';
+import { ICellRange } from '../cellRange';
+import { ITable } from './ITable';
+/**
+ * Holds a collection of {@link ITable}s.
+ */
+export interface ITableCollection extends ICollection<ITable> {
+    /**
+     * Returns items that match the filter criteria.
+     *
+     * If no filter criteria is provided, all items will be returned.
+     *
+     * @param options {@link ITableCollection.GetItemsOptions}
+     */
+    getItems(options?: ITableCollection.GetItemsOptions): ITable[];
+    /**
+     * Add an `ITable` to the container.
+     *
+     * @param address The address of the table.
+     * @param options Additional options available when adding a table or a `boolean` that indicates if the table has headers.
+     */
+    add(address: ICellRange.Address, options?: ITableCollection.AddOptions | boolean): ITable;
+    /**
+     * Convenience method for filter by name. This is
+     * functionally equivalent to getItems({ name });
+     *
+     * @param name The name to filter for This is case insensitive.
+     */
+    getByName(name: string): ITable | null;
+}
+/**
+ * {@inheritDoc ITableCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITableCollection}
+ */
+export declare namespace ITableCollection {
+    /**
+     * Options for adding a table to the collection.
+     */
+    interface AddOptions extends ITransaction.OperationOptions {
+        /**
+         * If not specified then the header status will be determined from the range data.
+         *
+         * @defaultValue 'based on initial data set'
+         *
+         * @remarks
+         *
+         * A default value of false will create a new row.
+         */
+        hasHeader?: boolean;
+        /**
+         * Properties to set on the table when created.
+         */
+        properties?: ITable.Properties;
+        /**
+         * Disabled autoFit on add.
+         *
+         * @defaultValue false;
+         */
+        disabledAutofit?: boolean;
+    }
+    interface GetItemsOptions {
+        /**
+         * If provided, the filter will be limited to items that intersect the range.
+        */
+        address?: ICellRange.Address;
+        /**
+         * Indicate if items that are in hidden headers or marked as hidden should be returned.
+         *
+         * @defaultValue false
+         */
+        ignoreHidden?: boolean;
+        /**
+         * Only return items that are completely contained with the filter bounds.
+         *
+         * @defaultValue false
+         */
+        fullyContained?: boolean;
+        /**
+         * Filter with the given name. This is case insensitive.
+         */
+        name?: string;
+    }
+}
+//# sourceMappingURL=ITableCollection.d.ts.map

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

@@ -0,0 +1,318 @@
+import { IProperties } from '../type';
+import { IStyle } from '../style';
+import { ITable } from './ITable';
+export declare namespace ITableStyle {
+    /**
+     * Options used for when calling getStyleProperties.
+     */
+    interface StyleOptions {
+        /**
+         * A string representing the name of the table style to use with this table.
+         * If the style name isn't valid then the spreadsheet application should use default style.
+         * If the name is missing then no formatting will be applied.
+         */
+        name?: string;
+        /**
+         * A Boolean indicating whether row stripe formatting is applied. True when style row stripe formatting is applied.
+         * @defaultValue true
+         */
+        showRowStripes?: boolean;
+        /**
+         * A Boolean indicating whether column stripe formatting is applied. True when style column stripe formatting is applied.
+         * @defaultValue false
+         */
+        showColumnStripes?: boolean;
+        /**
+         * A Boolean indicating whether the first column in the table should have the style applied. True if the first column has the style applied.
+         * @defaultValue false
+         */
+        showFirstColumn?: boolean;
+        /**
+         * A Boolean indicating whether the last column in the table should have the style applied. True if the last column has the style applied.
+         * @defaultValue false
+         */
+        showLastColumn?: boolean;
+    }
+    /**
+     * The Type of element to style.
+     */
+    const ElementType: {
+        /**
+         * The entire table.
+         */
+        readonly WholeTable: "wholeTable";
+        readonly FirstColumnStripe: "firstColumnStripe";
+        readonly SecondColumnStripe: "secondColumnStripe";
+        readonly FirstRowStripe: "firstRowStripe";
+        readonly SecondRowStripe: "secondRowStripe";
+        readonly LastColumn: "lastColumn";
+        readonly FirstColumn: "firstColumn";
+        readonly HeaderRow: "headerRow";
+        readonly TotalRow: "totalRow";
+        readonly FirstHeaderCell: "firstHeaderCell";
+        readonly LastHeaderCell: "lastHeaderCell";
+        readonly FirstTotalCell: "firstTotalCell";
+        readonly LastTotalCell: "lastTotalCell";
+    };
+    type ElementType = typeof ElementType[keyof typeof ElementType];
+    /**
+     * Extends {@link IStyle.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 {
+        /**
+         * The size is available for the following table elements:
+         * * firstRowStripe
+         * * secondRowStripe
+         * * firstColumnStripe
+         * * secondColumnStripe
+         *
+         * @defaultValue 1
+         */
+        size?: number;
+    }
+    /**
+     * A table style is a collection of cell styles that are applied to a table.
+     * These are applied in a specific order and merged to create a single cell style.
+     *
+     * The order is:
+     * Whole Table
+     * * First Column Stripe
+     * * Second Column Stripe
+     * * First Row Stripe
+     * * Second Row Stripe
+     * * Last Column
+     * * First Column
+     * * Header Row
+     * * Total Row
+     * * First Header Cell
+     * * Last Header Cell
+     * * First Total Cell
+     * * Last Total Cell
+     */
+    interface Properties {
+        /**
+         * The name of the table style. This is the name that is shown in the UI.
+         */
+        name: string;
+        /**
+         * If this table style should be shown as an available table style.
+         * @remarks
+         * table and pivot can not both be true. If both false then hidden
+         * @defaultValue true
+         */
+        table?: boolean;
+        /**
+         * 'True' if this table style should be shown as an available pivot table style.
+         * @remarks
+         * table and pivot can not both be true. If both false then hidden
+         * @defaultValue false
+         */
+        pivot?: boolean;
+        /**
+         * Properties for the whole table.
+         */
+        wholeTable?: IStyle.Properties;
+        /**
+         * Properties for the first set of alternating columns.
+         */
+        firstColumnStripe?: ITableStyle.SizeBasedProperties;
+        /**
+         * Properties for the second set of alternating columns.
+         */
+        secondColumnStripe?: ITableStyle.SizeBasedProperties;
+        /**
+         * Properties for the first set of alternating rows.
+         */
+        firstRowStripe?: ITableStyle.SizeBasedProperties;
+        /**
+         * Properties for the second set of alternating rows.
+         */
+        secondRowStripe?: ITableStyle.SizeBasedProperties;
+        /**
+         * For the last column.
+         */
+        lastColumn?: IStyle.Properties;
+        /**
+         * For the first column.
+         */
+        firstColumn?: IStyle.Properties;
+        /**
+         * For the header row.
+         */
+        headerRow?: IStyle.Properties;
+        /**
+         * For the first header cell. To be applied
+         * both the header and first column must be selected.
+         */
+        firstHeaderCell?: IStyle.Properties;
+        /**
+         * For the last header cell. To be applied
+         * both the header and last column must be selected.
+         */
+        lastHeaderCell?: IStyle.Properties;
+        /**
+         * For the total row.
+         */
+        totalRow?: IStyle.Properties;
+        /**
+         * For the first total cell. To be applied
+         * both the total and first column must be selected.
+         */
+        firstTotalCell?: IStyle.Properties;
+        /**
+         * For the last total cell. To be applied
+         * both the total and last column must be selected.
+         */
+        lastTotalCell?: IStyle.Properties;
+    }
+    type ResolvableProperties = IProperties.ResolvableProperties<ITableStyle.Properties>;
+    interface JSON extends ITableStyle.Properties {
+    }
+    /**
+     * JSON definition for a list of TableStyles.
+     */
+    interface JSONS {
+        defaultTableStyle?: string;
+        defaultPivotStyle?: string;
+        styles?: Record<string, ITableStyle.JSON>;
+    }
+    /**
+     * Properties for a pivot table style.
+     *
+     * @remarks
+     * **NOT IMPLEMENTED**
+     */
+    interface PivotProperties {
+        name?: string;
+        wholeTable?: IStyle.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;
+    }
+}
+/**
+ * Represents a style applied to tables, with methods for retrieving style
+ * properties, checking its usage in different contexts, and identifying built-in styles.
+ */
+export interface ITableStyle {
+    /**
+     * Returns the name of the table style.
+     *
+     * @returns The name of the table style as a string.
+     */
+    getName(): string;
+    /**
+     * Indicates whether this style appears in the list of table styles
+     * available for selection.
+     *
+     * @returns `true` if the style is shown in the table styles list; otherwise, `false`.
+     */
+    isShownInTableStyles(): boolean;
+    /**
+     * Indicates whether this style appears in the list of pivot table styles
+     * available for selection.
+     *
+     * @returns `true` if the style is shown in the pivot table styles list; otherwise, `false`.
+     */
+    isShownInPivotStyles(): boolean;
+    /**
+     * 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`.
+     */
+    getRanged(table: ITable): IProperties.ICellRanged<IStyle.Properties>;
+    /**
+     * Indicates whether this style is a built-in, predefined style.
+     *
+     * @returns `true` if the style is a built-in style; otherwise, `false`.
+     */
+    isBuiltIn(): boolean;
+    /**
+     * Delete the style from the collection.
+     *
+     * @remarks
+     * This will only remove if the style is not a built-in style.
+     * @see
+     * {@link ITableStyle.isBuiltIn}
+     */
+    delete(): void;
+    /**
+     * Returns the readonly list of properties for the style.
+     *
+     * @remarks
+     * This are unresolved properties.
+     */
+    getProperties(): Readonly<ITableStyle.Properties>;
+    /**
+     * Serializes the table style to JSON format.
+     *
+     * @returns A `ITableStyle.JSON` representation of the style.
+     */
+    toJSON(): ITableStyle.JSON;
+    /**
+     * For runtime type checking.
+     */
+    readonly isITableStyle: true;
+}
+/**
+ * {@inheritDoc ITableStyle}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITableStyle}
+ */
+export declare namespace ITableStyle {
+    /**
+     * Special table style that doesn't style anything. This is used
+     * for tables that have their format's cleared.
+     */
+    class Empty implements ITableStyle {
+        private _normalStyle;
+        constructor(normalStyle: IStyle);
+        /** {@inheritDoc ITableStyle.getName} */
+        getName(): string;
+        /** {@inheritDoc ITableStyle.isShownInTableStyles} */
+        isShownInTableStyles(): boolean;
+        /** {@inheritDoc ITableStyle.isShownInPivotStyles} */
+        isShownInPivotStyles(): boolean;
+        /** {@inheritDoc ITableStyle.getRanged} */
+        getRanged(_table: ITable): IProperties.ICellRanged<IStyle.Properties>;
+        /** {@inheritDoc ITableStyle.getProperties} */
+        getProperties(): Readonly<ITableStyle.Properties>;
+        /** {@inheritDoc ITableStyle.isBuiltIn} */
+        isBuiltIn(): true;
+        /** {@inheritDoc ITableStyle.delete} */
+        delete(): void;
+        /** {@inheritDoc ITableStyle.toJSON} */
+        toJSON(): ITableStyle.JSON;
+        /** {@inheritDoc ITableStyle.isITableStyle} */
+        get isITableStyle(): true;
+    }
+}
+//# sourceMappingURL=ITableStyle.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ITable } from './ITable';
+import { Anchored } from '../anchored/Anchored';
+import { AnchoredTable } from './AnchoredTable';
+export declare class Table extends AnchoredTable implements ITable {
+    constructor(options: ITable.ConstructorOptions);
+    protected _initializeOptions(options: ITable.ConstructorOptions): Anchored.ConstructorOptions;
+}
+//# sourceMappingURL=Table.d.ts.map

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

@@ -0,0 +1,20 @@
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ITableCollection } from './ITableCollection';
+import { ITable } from './ITable';
+export declare class TableCollection 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);
+    /** {@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 ITableCollection.getByName} */
+    getByName(name: string): ITable;
+    /** {@inheritDoc ITableCollection.getCount} */
+    getCount(): number;
+}
+//# sourceMappingURL=TableCollection.d.ts.map

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

@@ -0,0 +1,27 @@
+import { ITransaction } from '../transaction';
+import { ITable } from './ITable';
+import { TableColumn } from './_TableColumn';
+export declare class AutoTableColumn extends TableColumn {
+    /** {@inheritDoc ITable.IColumn.getName} */
+    getName(): string;
+    /** {@inheritDoc ITable.IColumn.setName} */
+    setName(name: string): this;
+    /** {@inheritDoc ITable.IColumn.getId} */
+    getId(): string;
+    /** {@inheritDoc ITable.IColumn.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc ITable.IColumn.setTotalsRowLabel} */
+    setTotalsRowLabel(label: string): this;
+    /** {@inheritDoc ITable.IColumn.getTotalsRowLabel} */
+    getTotalsRowLabel(): string | null;
+    /** {@inheritDoc ITable.IColumn.setTotalsRowFormula} */
+    setTotalsRowFormula(formula: string | number | undefined): this;
+    /** {@inheritDoc ITable.IColumn.getTotalsRowFormula} */
+    getTotalsRowFormula(): string | number | null;
+    /** {@inheritDoc ITable.IColumn.delete} */
+    delete(options?: ITransaction.OperationOptions): void;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc ITable.IColumn.toJSON} */
+    toJSON(): ITable.ColumnJSON | null;
+}
+//# sourceMappingURL=_AutoTableColumn.d.ts.map

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

@@ -0,0 +1,9 @@
+import { ITableStyle } from './ITableStyle';
+/**
+ * Returns a set of predefined table styles that match ooxml definitions.
+ * // TODO - either make the map readonly or just expose a few methods
+ */
+export declare const _BuiltInTableStyles: () => ReadonlyMap<string, ITableStyle.Properties>;
+export declare const DefaultTableStyleName: string;
+export declare const DefaultPivotStyleName: string;
+//# sourceMappingURL=_BuiltInTableStyles.d.ts.map

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

@@ -0,0 +1,30 @@
+import { ITransaction } from '../transaction';
+import { ICellRange } from '../cellRange';
+import { ICondition } from '../condition';
+import { IFilter } from '../filter';
+import { ITable } from './ITable';
+import { FilterPropertiesState, ColumnPropertiesState } from './_TableUtils';
+export declare class FilterField implements IFilter {
+    private _table;
+    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;
+    /** {@inheritDoc IFilter.getCondition} */
+    getCondition(): ICondition | null;
+    /** {@inheritDoc IFilter.setCondition} */
+    setCondition(condition: ICondition.Input | null | undefined, append?: boolean, options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc IFilter.apply} */
+    apply(): void;
+    /** {@inheritDoc IFilter.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc IFilter.getRange} */
+    getRange(): ICellRange;
+    /** {@inheritDoc IFilter.getLevel} */
+    getLevel(): number;
+    /** {@inheritDoc IFilter.delete} */
+    delete(options?: ITransaction.OperationOptions): void;
+}
+//# sourceMappingURL=_FilterField.d.ts.map

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

@@ -0,0 +1,84 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { INamed } from '../named';
+import { ISheet } from '../sheet';
+import { ITable } from './ITable';
+import { AbstractNamed } from '../named/AbstractNamed';
+export declare class NamedTable extends AbstractNamed<ITable, any> {
+    protected _sheet: ISheet;
+    protected _table: ITable;
+    constructor(sheet: ISheet, table: ITable, options: INamed.ConstructorOptions<ITable>);
+    select(options?: ICellRange.SelectOptions): Promise<this>;
+    getRanges(): ICellRanges | null;
+    /**
+     * {@inheritDoc INamed.getPartReference}
+     *
+     * @remarks
+     * A table is the one named thing here with addressable insides. `getRanges` reports only the data
+     * range — what the bare name `Sales` means — so everything else a user can select inside a table
+     * is reachable only as a structured reference.
+     *
+     * Resolved as a **row band** crossed with a **column span**, which is what the notation itself is:
+     *
+     * | Selected                            | Returned                              |
+     * | ----------------------------------- | ------------------------------------- |
+     * | the whole table                     | `Sales[#All]`                         |
+     * | the header row                      | `Sales[#Headers]`                     |
+     * | the totals row                      | `Sales[#Totals]`                      |
+     * | header + data rows (totals shown)   | `Sales[[#Headers],[#Data]]`           |
+     * | data + totals rows                  | `Sales[[#Data],[#Totals]]`            |
+     * | one column's data cells             | `Sales[Amount]`                       |
+     * | adjacent columns' data cells        | `Sales[[Qty]:[Cost]]`                 |
+     * | one column, header included         | `Sales[[#All],[Amount]]`              |
+     * | ...on a table that shows totals     | `Sales[[#Headers],[#Data],[Amount]]`  |
+     * | one column's header cell            | `Sales[[#Headers],[Amount]]`          |
+     * | adjacent columns, header included   | `Sales[[#All],[Qty]:[Cost]]`          |
+     *
+     * The data range across ALL columns is deliberately absent: that is the whole item, and
+     * {@link INamedCollection.getByRanges} has already matched it as `Sales` before asking for a part.
+     *
+     * "Header included" reads `#All` on a table with NO totals row, because there those are the same
+     * rows and `#All` is the simpler form for them; on one that shows totals the same selection needs
+     * the explicit `[#Headers],[#Data]` union.
+     *
+     * Only single-rectangle selections are answered, because only those have a spelling: a structured
+     * reference names one contiguous region.
+     */
+    getPartReference(coords: readonly IRange.Coords[]): 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
+     * (`['#Headers', '#Data']`), which is how Excel spells those.
+     *
+     * @remarks
+     * Rows only — the column extent is {@link _columnSpan}'s.
+     *
+     * Order matters twice. `#Data` is tested first so a table showing neither headers nor totals (where
+     * the whole table and the data range are the same rows) takes the short spelling. `#All` is tested
+     * before the two-specifier unions so that a table with no totals row spells header-plus-data as
+     * `#All` — the same rows, named by the simpler form.
+     */
+    private _rowBand;
+    /**
+     * What `target`'s horizontal extent covers, or `null` when an edge cuts a column in half.
+     *
+     * @remarks
+     * Returns the shape rather than the text, because a single column is spelled two ways depending on
+     * whether a band precedes it — that choice belongs with the rest of the formatting, in one place.
+     */
+    private _columnSpan;
+    /**
+     * The separator between a structured reference's two specifiers — `,` or `;`, per the workbook's
+     * locale, the same rule the editing compiler parses by.
+     *
+     * @remarks
+     * Read from the workbook rather than passed in: the sheet reaches it, so the table can answer this
+     * itself and callers never have to know the reference has a locale-dependent part at all.
+     */
+    private _listSeparator;
+    getScope(): string;
+    getType(): string;
+    getName(): string;
+    getValue(): ITable;
+}
+//# sourceMappingURL=_NamedTable.d.ts.map

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

@@ -0,0 +1,57 @@
+import { IListener } from '../listener';
+import { INamed } from '../named';
+import { NamedCollection } from '../named/NamedCollection';
+import { ISheet } from '../sheet';
+/**
+ * Presents the tables of one or more sheets as named items.
+ *
+ * @remarks
+ * Tables used to push themselves into the name collection at construction (`AnchoredTable` →
+ * `INamedCollection.add`), which left the collection holding a second reference to something it did
+ * not own — and left a table's name reachable only if that push had happened. Here the collection
+ * pulls instead: a table is named because it exists, and stops being named when it stops existing.
+ * There is nothing to keep in step.
+ *
+ * A table's name is derived, not defined, so this source has no `add` — tables are named by the
+ * thing they belong to. Only the calculation engine owns names outright.
+ */
+export declare class NamedTableSource implements NamedCollection.Source {
+    private _getSheets;
+    private _addSheetsListener;
+    private _subscriptions;
+    constructor(options: NamedTableSource.ConstructorOptions);
+    /** {@inheritDoc NamedCollection.Source.getItems} */
+    getItems(): readonly INamed[];
+    /**
+     * {@inheritDoc NamedCollection.Source.addListeners}
+     *
+     * @remarks
+     * A table's change signal is per sheet (`onTablesChange`), so this fans out over the sheets and
+     * re-fans whenever that set changes — a table on a sheet created later has to reach the
+     * aggregator too.
+     *
+     * The fan-out is re-checked on {@link getItems} as well as on the sheet-list event, because the
+     * aggregator can subscribe before the owner has any sheets: a workbook's name collection is built
+     * before its sheets are, so a subscribe-once source would fan out to nothing and stay deaf. Both
+     * paths run the same reconcile and it is idempotent — an unchanged sheet set does nothing.
+     */
+    addListeners(listeners: {
+        onCollectionChange?: (...args: any[]) => void;
+    }, options?: IListener.Options): IListener.Remove;
+    /** Re-points a subscription at the current sheets, if they have changed. */
+    private _syncSubscription;
+    /** Reconciles every live subscription against the current sheets. */
+    private _syncSubscriptions;
+}
+export declare namespace NamedTableSource {
+    interface ConstructorOptions {
+        /** The sheets whose tables are contributed. Re-read on every query. */
+        getSheets: () => readonly ISheet[];
+        /**
+         * Subscribes to the sheet list changing, so tables on a sheet added later are picked up.
+         * Omitted for a single, fixed sheet.
+         */
+        addSheetsListener?: (callback: () => void, options?: IListener.Options) => IListener.Remove;
+    }
+}
+//# sourceMappingURL=_NamedTableSource.d.ts.map

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

@@ -0,0 +1,29 @@
+import { ITransaction } from '../transaction';
+import { ICellRange } from '../cellRange';
+import { ISort } from '../sort';
+import { ITable } from './ITable';
+import { ColumnPropertiesState, SortPropertiesState } from './_TableUtils';
+export declare class SortField implements ISort {
+    private _table;
+    private _id;
+    private _getProps;
+    private _getColumnProps;
+    constructor(table: ITable, id: number | string, getProps: (id: number | string) => SortPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState);
+    /** {@inheritDoc ISort.sort} */
+    sort(descending?: boolean): void;
+    /** {@inheritDoc ISort.getCriteria} */
+    getCriteria(): Readonly<ISort.Criteria> | null;
+    /** {@inheritDoc ISort.setCriteria} */
+    setCriteria(criteria: ISort.Criteria | null, append?: boolean, options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc ISort.apply} */
+    apply(): void;
+    /** {@inheritDoc ISort.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc ISort.getRange} */
+    getRange(): ICellRange;
+    /** {@inheritDoc ISort.getLevel} */
+    getLevel(): number;
+    /** {@inheritDoc ISort.delete} */
+    delete(options?: ITransaction.OperationOptions): void;
+}
+//# sourceMappingURL=_SortField.d.ts.map