@sheetxl/sdk 0.8.0-beta.15 → 0.8.0-beta.17

package/types/src/slicer/ISlicer.d.ts

@@ -5,19 +5,23 @@ import { IListener } from '../listener';
 import { IModel } from '../model';
 import { IMovable, IMovableCollection } from '../movable';
 import { ITable } from '../table';
+import { IPivotTable } from '../pivot';
 import { IWorksheet } from '../sheet';
 /**
- * A slicer: buttons that filter one column of a table.
+ * A slicer: buttons that filter one column of a table, or one field of pivot tables.
  *
  * @remarks
- * A slicer holds no selection of its own. What it shows as selected is the column's filter
- * ({@link ITable.IColumn.getFilter}), so a filter set from the column's menu shows on the slicer,
- * and a selection made on the slicer is the column's filter, saved with the table. Two slicers on
- * one column always agree.
+ * A slicer holds no selection of its own. On a table, what it shows as selected is the column's
+ * filter ({@link ITable.IColumn.getFilter}), so a filter set from the column's menu shows on the
+ * slicer, and a selection made on the slicer is the column's filter, saved with the table. On pivot
+ * tables it is the field's items hidden by hand ({@link IPivotTable.IField.setVisibleItems}), the
+ * same on every pivot table it filters; a label or value filter on the field does not show on it.
+ * Two slicers on one column or field always agree.
  *
- * The column is named by a structured reference ({@link getSource}), which follows the table and
- * the column through a rename. When the column or its table is deleted, the slicer is deleted with
- * it, in the same step; an undo brings both back.
+ * A table slicer follows its table and column through a rename. When the column or its table is
+ * deleted, the slicer is deleted with it, in the same step; an undo brings both back. A pivot slicer
+ * stays when its pivot tables are deleted, filtering nothing, and is deleted with its field when a
+ * pivot table's source no longer has it.
  *
  * Where a slicer sits is its movable's ({@link IMovable.getBounds}); it moves freely of the cells
  * under it by default.
@@ -31,31 +35,46 @@ import { IWorksheet } from '../sheet';
  */
 export interface ISlicer extends IModel, IMovable.IContent {
     /**
-     * Returns the column the slicer filters, as a structured reference: `Sales[Region]`.
+     * Returns the name of what the slicer filters: the column's, or the pivot field's in its source.
      *
      * @remarks
-     * Follows a rename of the table or the column.
+     * A table slicer's follows a rename of the column.
      */
-    getSource(): string;
+    getSourceName(): string;
     /**
-     * Returns the table the slicer filters, or `null` if it names none.
+     * Returns what the slicer filters: the table, or the first pivot table; `null` if there is none.
+     *
+     * @see {@link getPivotTables} for every pivot table a pivot slicer filters.
      */
-    getTable(): ITable | null;
+    getTable(): ITable | IPivotTable | null;
     /**
-     * Returns the column the slicer filters, or `null` if it names none.
+     * Returns the column the slicer filters, or `null` for a pivot slicer or one naming no column.
      */
     getColumn(): ITable.IColumn | null;
+    /**
+     * Returns the pivot tables the slicer filters; empty for a table slicer, or once they are deleted.
+     */
+    getPivotTables(): readonly IPivotTable[];
+    /**
+     * Returns the field a pivot slicer filters, as its first pivot table has it; `null` for a table
+     * slicer, or when there is no pivot table.
+     *
+     * @remarks
+     * Each pivot table has its own field. Select through the slicer, which changes every one of them.
+     */
+    getPivotField(): IPivotTable.IField | null;
     /**
      * Returns the text shown in the slicer's header.
      *
      * @remarks
-     * The column's name unless a caption has been set, and then it follows a rename of the column.
+     * {@link getSourceName} unless a caption has been set. A slicer added on a pivot field with a
+     * caption of its own starts with that caption, and keeps it when the field's changes.
      */
     getCaption(): string;
     /**
      * Sets the text shown in the slicer's header.
      *
-     * @param caption The caption, or `null` to show the column's name.
+     * @param caption The caption, or `null` to show {@link getSourceName}.
      */
     setCaption(caption: string | null, options?: ITransaction.OperationOptions): this;
     /**
@@ -90,6 +109,8 @@ export interface ISlicer extends IModel, IMovable.IContent {
     getSortOrder(): ISlicer.SortOrder;
     /**
      * Sets the order the items are listed in.
+     *
+     * @throws ExpectedError For `'dataSource'` on a pivot slicer, which Excel does not offer.
      */
     setSortOrder(sortOrder: ISlicer.SortOrder, options?: ITransaction.OperationOptions): this;
     /**
@@ -125,15 +146,18 @@ export interface ISlicer extends IModel, IMovable.IContent {
      */
     setLockedPosition(locked: boolean, options?: ITransaction.OperationOptions): this;
     /**
-     * Returns `true` when the column has no filter: every item is selected.
+     * Returns `true` when every item is selected: the column has no filter, or the field hides no item.
      */
     isFilterCleared(): boolean;
     /**
-     * Returns the items: the column's distinct values as it shows them, in the slicer's order.
+     * Returns the items: the column's distinct values as it shows them, or the field's items, in the
+     * slicer's order.
      *
      * @remarks
      * Every row of the column is read, hidden or not. An item has data when at least one row
-     * holding it passes the other columns' filters. Blanks are one item, keyed `''`, listed last.
+     * holding it passes the other columns' filters; on pivot tables, when a source row holding it
+     * passes the items the first pivot table's other fields hide, and an item the source no longer
+     * holds has none. Blanks are one item, keyed `''`, listed last in ascending order.
      */
     getItems(): Promise<readonly ISlicer.Item[]>;
     /**
@@ -141,17 +165,18 @@ export interface ISlicer extends IModel, IMovable.IContent {
      */
     getItem(key: string): Promise<ISlicer.Item | null>;
     /**
-     * Selects the items with `keys` and no others, by filtering the column.
+     * Selects the items with `keys` and no others, by filtering the column or by hiding the field's
+     * other items on every pivot table, as one step that can be undone.
      *
      * @param keys The items' keys. `null`, an empty list or every item clears the filter.
      *
      * @remarks
      * The other columns' filters stay. On a date column the selection is saved as the dates
-     * themselves, not their text.
+     * themselves, not their text. A pivot field's label, date and value filters stay.
      */
     selectItems(keys: readonly string[] | null, options?: ITransaction.OperationOptions): Promise<this>;
     /**
-     * Clears the column's filter, selecting every item.
+     * Clears the column's filter, or shows every item of the field, selecting every item.
      */
     clearFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /**
@@ -201,21 +226,21 @@ export declare namespace ISlicer {
      */
     interface Item {
         /**
-         * The item's identity: the text the column shows for it, `''` for the blank item. What
-         * {@link ISlicer.selectItems} takes.
+         * The item's identity: the text the column shows for it, or the pivot item's caption; `''` for
+         * the blank item. What {@link ISlicer.selectItems} takes.
          */
         key: string;
         /** The text shown on the button. */
         name: string;
-        /** The value of the first cell showing the item; `null` for the blank item. */
+        /** The value of the first cell showing the item, or the pivot item's; `null` for the blank item. */
         value: Scalar;
-        /** Whether at least one row holding the item passes the other columns' filters. */
+        /** Whether at least one row holding the item passes the other columns' or fields' filters. */
         hasData: boolean;
-        /** Whether the column's filter selects the item. */
+        /** Whether the column's filter selects the item, or the field shows it. */
         isSelected: boolean;
     }
     /**
-     * Options for {@link ITable.addSlicer}.
+     * Options for {@link ITable.addSlicer} and {@link IPivotTable.addSlicer}.
      */
     interface AddOptions extends IMovableCollection.AddOptions<ISlicer.JSON> {
         /**
@@ -224,7 +249,11 @@ export declare namespace ISlicer {
          * @defaultValue The table's sheet.
          */
         sheet?: IWorksheet;
-        /** {@inheritDoc ISlicer.JSON.caption} */
+        /**
+         * The header text.
+         *
+         * @defaultValue The column's name, or the pivot field's caption.
+         */
         caption?: string;
         /**
          * The slicer style's name.
@@ -240,11 +269,12 @@ export declare namespace ISlicer {
      */
     interface Events extends IMovable.ContentEvents {
         /**
-         * Called when the column's filter changes, by this slicer or anything else.
+         * Called when the column's filter or the field's hidden items change, by this slicer or anything
+         * else.
          */
         onSelectionChange?(source: ISlicer): void;
         /**
-         * Called when the column's values change, so the items may have.
+         * Called when the column's values or the pivot tables change, so the items may have.
          */
         onItemsChange?(source: ISlicer): void;
     }
@@ -255,11 +285,11 @@ export declare namespace ISlicer {
      */
     interface JSON {
         /**
-         * The column, as a structured reference: `Sales[Region]`.
+         * The column, as a structured reference: `Sales[Region]`. Absent for a slicer on a pivot table.
          */
-        source: string;
+        source?: string;
         /**
-         * The header text. Absent, the column's name.
+         * The header text. Absent, the column's or the pivot field's name.
          */
         caption?: string;
         /**
@@ -320,6 +350,56 @@ export declare namespace ISlicer {
          * The id the file gave the slicer.
          */
         uid?: string;
+        /**
+         * What a slicer on pivot tables filters.
+         *
+         * @internal
+         */
+        pivot?: ISlicer.PivotJSON;
+    }
+    /**
+     * A slicer on pivot tables: the field and the pivot tables it filters. A slicer on worksheet pivot
+     * tables takes its items and their states from the field; a data-model slicer's and a timeline's
+     * are carried as read.
+     *
+     * @internal
+     */
+    interface PivotJSON {
+        /** The field the slicer filters, by its name in the cache: `Region`, or `[Table1].[Region]` for a data model. */
+        sourceName: string;
+        /** The pivot tables the slicer filters, by sheet and name. Empty once they are deleted. */
+        tables: {
+            sheet: string;
+            name: string;
+        }[];
+        /**
+         * The workbook pivot cache the slicer's items index: its first pivot table's, kept once they are
+         * deleted. Absent for a data-model slicer.
+         */
+        cacheId?: number;
+        /**
+         * Present for a slicer or timeline on worksheet pivot tables the model holds, whose items and
+         * selection, or state, are the field's: what a slicer cache's `tabular` says beyond the slicer's
+         * sort order and cross filter.
+         */
+        tabular?: {
+            /** Whether items the source no longer holds are left out. */
+            hideMissing?: true;
+        };
+        /**
+         * The cache's children after its pivot tables, verbatim: for a {@link tabular} slicer what
+         * follows `<data>`, for a {@link tabular} timeline what follows `<state>`, else all of them.
+         */
+        body: string;
+        /**
+         * Present for a timeline, which Excel keeps as a slicer whose items are dates: the timeline's
+         * attributes beyond its name, cache and caption (level, scroll position, style, ...) and its
+         * children, as read. Its cache's `body` is then the `<state>` and what follows.
+         */
+        timeline?: {
+            attributes: Record<string, string>;
+            body: string;
+        };
     }
 }
 //# sourceMappingURL=ISlicer.d.ts.map

package/types/src/slicer/ITimeline.d.ts

@@ -0,0 +1,61 @@
+import { ITransaction } from '../transaction';
+import { ISlicer } from './ISlicer';
+/**
+ * A timeline: a slicer on a date field of pivot tables, whose selection is a range of dates.
+ *
+ * @remarks
+ * A timeline holds no selection of its own. What it selects is the field's date filter, the same on
+ * every pivot table it filters, so a date filter set on the field shows on the timeline, and a range
+ * set on the timeline is the field's date filter. While a timeline is on the field, that filter
+ * filters the tables whether or not the field is on an axis.
+ *
+ * It has no items: {@link ISlicer.getItems} answers none, and {@link ISlicer.clearFilters} clears the
+ * range.
+ *
+ * @example
+ * ```ts
+ * const content = movable.getContent<ISlicer>();
+ * if ((content as ITimeline).isITimeline) {
+ *   await (content as ITimeline).setDateRange({ start: 45689, end: 45747 });
+ * }
+ * ```
+ */
+export interface ITimeline extends ISlicer {
+    /**
+     * Returns the dates selected, or `null` when every date is, or the field's date filter is not a
+     * range of dates.
+     */
+    getDateRange(): ITimeline.DateRange | null;
+    /**
+     * Selects a range of dates on every pivot table, as one step that can be undone.
+     *
+     * @param range The dates, or `null` to select every date.
+     *
+     * @remarks
+     * The range replaces the field's label or date filter; its value filter and the items it hides
+     * stay.
+     */
+    setDateRange(range: ITimeline.DateRange | null, options?: ITransaction.OperationOptions): Promise<this>;
+    /** For runtime type checking. */
+    readonly isITimeline: true;
+}
+/**
+ * {@inheritDoc ITimeline}
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITimeline}
+ */
+export declare namespace ITimeline {
+    /**
+     * A range of whole days, as date serial numbers.
+     */
+    interface DateRange {
+        /** The first day selected. */
+        start: number;
+        /** The last day selected. */
+        end: number;
+    }
+}
+//# sourceMappingURL=ITimeline.d.ts.map

package/types/src/slicer/Slicer.d.ts

@@ -2,9 +2,12 @@ import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IListener } from '../listener';
 import { ITable } from '../table';
+import { IPivotTable } from '../pivot';
 import { IAnchored } from '../anchored';
 import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ISlicer } from './ISlicer';
+import { ITimeline } from './ITimeline';
+import { PivotSlicerItem } from './_PivotSlicer';
 interface State extends AbstractMovableContent.State {
     data?: ISlicer.JSON;
 }
@@ -25,6 +28,13 @@ export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON,
      * may be an internal spelling, never a name.
      */
     private _columnName;
+    /**
+     * A pivot slicer's pivot tables, once looked up: deleted ones included, so an undo of the delete
+     * connects the slicer again. `null` until the workbook can be asked.
+     */
+    private _pivotTables;
+    /** The listeners on a pivot slicer's pivot tables, while someone listens to the slicer. */
+    private _pivotBinding;
     constructor(options: Slicer.ConstructorOptions);
     /** {@inheritDoc IModel.getType} */
     getType(): string;
@@ -32,12 +42,21 @@ export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON,
     getTypeDescription(): string;
     /** {@inheritDoc IMovable.IContent.getDefaultAnchorType} */
     getDefaultAnchorType(): IAnchored.Type;
-    /** {@inheritDoc ISlicer.getSource} */
-    getSource(): string;
+    /** {@inheritDoc ISlicer.getSourceName} */
+    getSourceName(): string;
     /** {@inheritDoc ISlicer.getTable} */
-    getTable(): ITable | null;
+    getTable(): ITable | IPivotTable | null;
     /** {@inheritDoc ISlicer.getColumn} */
     getColumn(): ITable.IColumn | null;
+    /** {@inheritDoc ISlicer.getPivotTables} */
+    getPivotTables(): readonly IPivotTable[];
+    /** {@inheritDoc ISlicer.getPivotField} */
+    getPivotField(): IPivotTable.IField | null;
+    /**
+     * The column as a structured reference, `Sales[Region]`, following a rename; `''` for a pivot slicer.
+     * @internal
+     */
+    _getSource(): string;
     /** {@inheritDoc IMovable.IContent.setName} */
     setName(name: string): this;
     /** {@inheritDoc ISlicer.getCaption} */
@@ -90,6 +109,27 @@ export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON,
     toJSON(_toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
     /** {@inheritDoc ISlicer.isISlicer} */
     get isISlicer(): true;
+    /** {@inheritDoc ITimeline.isITimeline} */
+    get isITimeline(): boolean;
+    /** {@inheritDoc ITimeline.getDateRange} */
+    getDateRange(): ITimeline.DateRange | null;
+    /** {@inheritDoc ITimeline.setDateRange} */
+    setDateRange(range: ITimeline.DateRange | null, options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * A timeline's state, as its cache writes it: the pivot cache it names, the range its first pivot
+     * table's date filter selects, whether that table has any label or date filter on the field, and
+     * the earliest and latest dates of the field. With its pivot tables deleted, the cache it kept and
+     * no filter. `null` for a slicer, or a timeline whose state is carried as read.
+     * @internal
+     */
+    _getTimelineState(): {
+        cacheId: number;
+        range: ITimeline.DateRange | null;
+        filtered: boolean;
+        dates: ITimeline.DateRange | null;
+    } | null;
+    /** A timeline's first pivot table and the field it filters there; `null` when there is none. */
+    private _timelineField;
     get [Symbol.toStringTag](): string;
     toString(): string;
     /**
@@ -98,6 +138,39 @@ export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON,
      * @internal
      */
     _attach(): void;
+    /**
+     * The live pivot tables a slicer on pivot tables filters, or `null` when it filters a table
+     * column or its workbook cannot be asked yet. A deleted pivot table is left out: the slicer
+     * stays, filtering nothing, as Excel keeps it.
+     * @internal
+     */
+    _getPivotTables(): IPivotTable[] | null;
+    /**
+     * Finds the pivot tables the slicer names, by sheet and name, and holds them from here on: what
+     * the workbook asks of each pivot slicer once its sheets are loaded, so a sheet renamed later is
+     * followed. One that names nothing is left out.
+     *
+     * @param find The pivot table named `name` on the sheet named `sheet`, or `null`.
+     * @internal
+     */
+    _holdPivotTables(find: (sheet: string, name: string) => IPivotTable | null): void;
+    /**
+     * A pivot slicer's items, every one in the slicer's order, read from its first pivot table, and the
+     * workbook pivot cache they index: what the file's `<data>` lists, each item once
+     * (`pivot-probes/probe-pivot-slicer-edits.ps1`, F03, F04, F05). With its pivot tables deleted, the
+     * cache it kept, every item selected. `null` for a table slicer, a data-model slicer or a timeline,
+     * or when the cache is not there.
+     * @internal
+     */
+    _getPivotItems(): {
+        cacheId: number;
+        items: readonly PivotSlicerItem[];
+    } | null;
+    /** Shows the field's cache items `shown`, or every one, on each pivot table, as one step. */
+    private _showPivotItems;
+    /** Listens to the pivot tables: any change of one may change the items or the selection. */
+    private _bindPivot;
+    private _unbindPivot;
     private _data;
     private _getWorkbook;
     /** The table and column the source names now, or `null` when it names no column of a live table. */

package/types/src/slicer/_PivotSlicer.d.ts

@@ -0,0 +1,51 @@
+import { LocaleProfile } from '@sheetxl/primitives';
+import { IWorkbook } from '../workbook';
+import { IPivotTable } from '../pivot';
+import { PivotDefinition } from '../pivot/_PivotItems';
+import { ISlicer } from './ISlicer';
+import { ITimeline } from './ITimeline';
+/** One item of a pivot slicer, with the cache item it is. */
+export interface PivotSlicerItem extends ISlicer.Item {
+    /** The item's index in the cache field: what the file's `<i x>` and the table's items name it by. */
+    id: number;
+    /** Whether the source no longer holds the item. */
+    missing: boolean;
+}
+/** What a pivot slicer reads of a pivot table that the public interface does not give. */
+export interface SlicerPivotTable extends IPivotTable {
+    _getModel(): (PivotDefinition & Pick<IPivotTable.JSON, 'filters'>) | null;
+    _getCache(): IPivotTable.CacheJSON | null;
+    _showSlicerItems(field: number, shown: ReadonlySet<number> | null): Promise<void>;
+    _setDateRange(field: number, name: string, range: ITimeline.DateRange | null): Promise<void>;
+}
+/** The field a pivot slicer filters in `cache`, by its name there; `-1` when the cache has none. */
+export declare const slicerFieldOf: (cache: IPivotTable.CacheJSON | null, sourceName: string) => number;
+/**
+ * Every item of a pivot slicer's field, in the slicer's order: its cache items, sorted by value with
+ * the blank as the greatest (`pivot-probes/probe-pivot-slicer-caption.ps1`, C03, C04, C07), a grouping's
+ * groups in their order, and under `showItemsWithDataAtTop` those with data first.
+ *
+ * Selected is shown on `table`, so an item the table does not list (one the source gained) is. An
+ * item has data when a source row holding it passes the items `table`'s other fields hide; one the
+ * source no longer holds has none (`probe-pivot-slicer-edits.ps1`, E02).
+ */
+export declare const pivotSlicerItemsOf: (table: PivotDefinition, cache: IPivotTable.CacheJSON, field: number, sortOrder: ISlicer.SortOrder, crossFilter: ISlicer.CrossFilter, profile: LocaleProfile) => PivotSlicerItem[];
+/**
+ * The dates a field's date filter keeps, when it is a range of whole days: `afterEqualTo` and
+ * `beforeEqualTo` on the date, as a timeline writes it and Excel's `dateBetween` reads
+ * (`pivot-probes/probe-pivot-timeline-edits.ps1`, T02). `null` for no filter or any other.
+ */
+export declare const dateRangeOf: (table: Pick<IPivotTable.JSON, "filters">, field: number) => ITimeline.DateRange | null;
+/**
+ * `table` with a field's label or date filter replaced by the range of dates, or removed for `null`:
+ * what a timeline's selection writes to each table it filters, named for the field and on whole
+ * days, as Excel writes it (T02, T10). The field's value filter and hidden items stay.
+ */
+export declare const withDateRange: <T extends Pick<IPivotTable.JSON, "filters">>(table: T, field: number, name: string, range: ITimeline.DateRange | null) => T;
+/** The earliest and latest dates among a cache field's items, or `null` when it holds none. */
+export declare const dateBoundsOf: (cache: IPivotTable.CacheJSON, field: number) => ITimeline.DateRange | null;
+/**
+ * Every pivot slicer of the workbook that filters `table`, hidden sheets included.
+ */
+export declare const pivotSlicersOf: (workbook: IWorkbook, table: IPivotTable) => ISlicer[];
+//# sourceMappingURL=_PivotSlicer.d.ts.map

package/types/src/slicer/index.d.ts

@@ -1,3 +1,4 @@
 export * from './ISlicer';
 export * from './ISlicerStyle';
+export * from './ITimeline';
 //# sourceMappingURL=index.d.ts.map

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

@@ -377,7 +377,7 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     /** {@inheritDoc ITable.getRangedStyle} */
     getRangedStyle(): IProperties.ICellRanged<ICellStyle.Properties>;
     /** {@inheritDoc ITable.getStyleAt} */
-    getStyleAt(coords: IRange.CellCoords): ICellStyle;
+    getStyleAt(row: number, column: number): ICellStyle;
     /** {@inheritDoc ITable.isShowTotals} */
     isShowTotals(): boolean;
     /** {@inheritDoc ITable.setShowTotals} */
@@ -477,6 +477,16 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      * nothing to reapply for one that has none.
      */
     private _filterLevels;
+    /**
+     * `conditions` as an apply evaluates them: each relative period anchored to the runtime's today
+     * ({@link anchorTimePeriod}). `conditions` itself when none changes.
+     */
+    private _anchoredToday;
+    /**
+     * The runs of a reapply, and the levels to write with them when a relative period's anchor moved
+     * to today (`null` when none did, so only the rows change).
+     */
+    private _evalReapply;
     /** {@inheritDoc ITable.applyFilters} */
     applyFilters(options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc ITable.deleteFilters} */

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

@@ -661,15 +661,14 @@ export interface ITable extends IAnchored {
      */
     getRangedStyle(): IProperties.ICellRanged<ICellStyle.Properties>;
     /**
-     * Returns a cell style for the given coords.
-     * @param coords The absolute coords.
+     * Returns the style the table gives the cell at a sheet position.
+     * @param row The row on the sheet.
+     * @param column The column on the sheet.
      *
      * @remarks
-     * This will return a CellStyle rendered with the table styling but not any other styling.
-     *
-     * * This is used by the preview.
+     * The table's styling only, not the cell's own formats or any other layer.
      */
-    getStyleAt(coords: IRange.CellCoords): ICellStyle;
+    getStyleAt(row: number, column: number): ICellStyle;
     /**
      * Specifies if totals are being shown for the table.
      */

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

@@ -55,6 +55,29 @@ export declare namespace ITableStyle {
         readonly LastTotalCell: "lastTotalCell";
     };
     type ElementType = typeof ElementType[keyof typeof ElementType];
+    /**
+     * The elements only a pivot table style has, beside the {@link ElementType}s a pivot table also
+     * uses (all but `lastHeaderCell`, `firstTotalCell` and `lastTotalCell`). On a pivot table,
+     * `totalRow` is the grand total row and `lastColumn` the grand total column.
+     */
+    const PivotElementType: {
+        readonly FirstSubtotalColumn: "firstSubtotalColumn";
+        readonly SecondSubtotalColumn: "secondSubtotalColumn";
+        readonly ThirdSubtotalColumn: "thirdSubtotalColumn";
+        readonly FirstSubtotalRow: "firstSubtotalRow";
+        readonly SecondSubtotalRow: "secondSubtotalRow";
+        readonly ThirdSubtotalRow: "thirdSubtotalRow";
+        readonly BlankRow: "blankRow";
+        readonly FirstColumnSubheading: "firstColumnSubheading";
+        readonly SecondColumnSubheading: "secondColumnSubheading";
+        readonly ThirdColumnSubheading: "thirdColumnSubheading";
+        readonly FirstRowSubheading: "firstRowSubheading";
+        readonly SecondRowSubheading: "secondRowSubheading";
+        readonly ThirdRowSubheading: "thirdRowSubheading";
+        readonly PageFieldLabels: "pageFieldLabels";
+        readonly PageFieldValues: "pageFieldValues";
+    };
+    type PivotElementType = typeof PivotElementType[keyof typeof PivotElementType];
     /**
      * Extends {@link ICellStyle.Properties} to include a size.
      *
@@ -92,6 +115,11 @@ export declare namespace ITableStyle {
      * * Last Header Cell
      * * First Total Cell
      * * Last Total Cell
+     *
+     * A pivot table style also has the {@link PivotElementType} elements, and is applied in its own
+     * order: whole table, page field labels and values, column then row stripes, first column,
+     * header row, first header cell, subtotal columns, blank row, subtotal rows, column
+     * subheadings, row subheadings, grand total column (`lastColumn`), grand total row (`totalRow`).
      */
     interface Properties {
         /**
@@ -168,6 +196,28 @@ export declare namespace ITableStyle {
          * both the total and last column must be selected.
          */
         lastTotalCell?: ICellStyle.Properties;
+        /** A pivot table's first, second and third level of subtotal columns. */
+        firstSubtotalColumn?: ICellStyle.Properties;
+        secondSubtotalColumn?: ICellStyle.Properties;
+        thirdSubtotalColumn?: ICellStyle.Properties;
+        /** A pivot table's first, second and third level of subtotal rows. */
+        firstSubtotalRow?: ICellStyle.Properties;
+        secondSubtotalRow?: ICellStyle.Properties;
+        thirdSubtotalRow?: ICellStyle.Properties;
+        /** A pivot table's blank row after an item. */
+        blankRow?: ICellStyle.Properties;
+        /** A pivot table's column labels at the first, second and third level. */
+        firstColumnSubheading?: ICellStyle.Properties;
+        secondColumnSubheading?: ICellStyle.Properties;
+        thirdColumnSubheading?: ICellStyle.Properties;
+        /** A pivot table's items with items under them, at the first, second and third level. */
+        firstRowSubheading?: ICellStyle.Properties;
+        secondRowSubheading?: ICellStyle.Properties;
+        thirdRowSubheading?: ICellStyle.Properties;
+        /** A pivot table's page field captions. */
+        pageFieldLabels?: ICellStyle.Properties;
+        /** A pivot table's page field items. */
+        pageFieldValues?: ICellStyle.Properties;
     }
     type ResolvableProperties = IProperties.ResolvableProperties<ITableStyle.Properties>;
     interface JSON extends ITableStyle.Properties {
@@ -180,40 +230,6 @@ export declare namespace ITableStyle {
         defaultPivotStyle?: string;
         styles?: Record<string, ITableStyle.JSON>;
     }
-    /**
-     * Properties for a pivot table style.
-     *
-     * @remarks
-     * **NOT IMPLEMENTED**
-     */
-    interface PivotProperties {
-        name?: string;
-        wholeTable?: ICellStyle.Properties;
-        firstColumnStripe?: ITableStyle.SizeBasedProperties;
-        secondColumnStripe?: ITableStyle.SizeBasedProperties;
-        firstRowStripe?: ITableStyle.SizeBasedProperties;
-        secondRowStripe?: ITableStyle.SizeBasedProperties;
-        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;
-    }
 }
 /**
  * Represents a style applied to tables, with methods for retrieving style