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

package/types/src/outline/Outline.d.ts

@@ -0,0 +1,157 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ISheet } from '../sheet/ISheet';
+import { IOutline } from './IOutline';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { SheetHeader } from '../sheetHeader/SheetHeader';
+import type * as _HeaderUtils from '../sheetHeader/_HeaderUtils';
+type HeaderRun = ITypes.RunCoordValue<_HeaderUtils.CellHeaderState>;
+/**
+ * The groups on one axis, derived from that axis's header runs.
+ */
+interface AxisGroups {
+    runs: readonly HeaderRun[];
+    direction: IRange.Direction;
+    entireMax: number;
+    /** Per level, `byLevel[level - 1]`, ordered and non-overlapping within a level. */
+    byLevel: IOutline.Group[][];
+}
+interface State {
+    summaryRow: IRange.Direction;
+    summaryColumn: IRange.Direction;
+    automaticStyles: boolean;
+}
+/** A summary line and the detail lines it totals, found by {@link Outline.autoOutline}. */
+interface SummarySpan {
+    summary: number;
+    start: number;
+    end: number;
+}
+/**
+ * The outline of a sheet.
+ *
+ * @remarks
+ * Holds only the settings. The levels and collapsed flags live on the header runs, and the groups
+ * are derived from those runs (runs × levels, never a row walk), cached against the run array,
+ * which the headers replace rather than mutate.
+ *
+ * Whether a group is collapsed is derived too, as Excel derives it: its details are all hidden,
+ * and either its summary is showing or the summary carries the collapsed flag. The flag is what
+ * tells an inner group that was collapsed from one that was merely hidden with its outer group,
+ * so it is recorded on every collapsed inner summary before an outer group hides it.
+ */
+export declare class Outline implements IOutline {
+    protected _options: Outline.ConstructorOptions;
+    protected _transactions: ITransaction.IStore;
+    protected _id: string;
+    protected _emitter: ListenerEmitter<IOutline, IOutline.IListeners>;
+    protected _removeListeners: IListener.Remove[];
+    protected _closed: boolean;
+    protected _rowGroups: AxisGroups | null;
+    protected _columnGroups: AxisGroups | null;
+    constructor(options: Outline.ConstructorOptions);
+    protected _getState(): Readonly<State>;
+    protected _updateState(update: Partial<State>, options?: ITransaction.OperationOptions): void;
+    protected _header(axis: IRange.Axis): SheetHeader;
+    protected _sheet(): ISheet;
+    /**
+     * The structure of an outline and its settings need an unprotected sheet, whatever the
+     * protection allows; only showing and hiding details goes by Format Rows / Format Columns.
+     */
+    protected _assertUnlocked(): void;
+    /** {@inheritDoc IOutline.getSummaryDirection} */
+    getSummaryDirection(axis: IRange.Axis): IRange.Direction;
+    /** {@inheritDoc IOutline.setSummaryDirection} */
+    setSummaryDirection(axis: IRange.Axis, direction: IRange.Direction, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IOutline.isAutomaticStyles} */
+    isAutomaticStyles(): boolean;
+    /** {@inheritDoc IOutline.setAutomaticStyles} */
+    setAutomaticStyles(automatic: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IOutline.getLevelCount} */
+    getLevelCount(axis: IRange.Axis): number;
+    /** {@inheritDoc IOutline.getGroups} */
+    getGroups(axis: IRange.Axis, options?: IOutline.GetGroupsOptions): readonly IOutline.Group[];
+    /** {@inheritDoc IOutline.setVisibleLevels} */
+    setVisibleLevels(axis: IRange.Axis, levels: number, options?: ITransaction.OperationOptions): this;
+    protected _setVisibleLevels(axis: IRange.Axis, levels: number): void;
+    /**
+     * Adds `delta` to the outline level of every header in `coords`.
+     *
+     * @internal
+     */
+    _changeLevels(axis: IRange.Axis, coords: RunCoords, delta: 1 | -1, options?: ITransaction.OperationOptions): void;
+    /**
+     * Throws if any header in `coords` is already at the deepest outline level.
+     *
+     * @internal
+     */
+    _assertNotDeepest(axis: IRange.Axis, coords: RunCoords): void;
+    /** {@inheritDoc IOutline.clear} */
+    clear(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
+    protected _clearAxis(axis: IRange.Axis): void;
+    /**
+     * Removes the outline levels and collapsed flags from the headers in `coords`.
+     *
+     * @internal
+     */
+    _clear(axis: IRange.Axis, coords: RunCoords, options?: ITransaction.OperationOptions): void;
+    /**
+     * Collapses or expands the groups a span selects: those whose summary falls in it, or, when there
+     * are none, the deepest groups whose details meet it.
+     *
+     * @internal
+     */
+    _setGroupDetails(axis: IRange.Axis, coords: RunCoords, show: boolean, options?: ITransaction.OperationOptions): void;
+    protected _selectGroups(axis: IRange.Axis, coords: RunCoords): IOutline.Group[];
+    /**
+     * The groups nested in `group`, deeper levels only, excluding those that share its summary (one
+     * flag cannot tell the two apart).
+     */
+    protected _innerGroups(axis: IRange.Axis, group: IOutline.Group): IOutline.Group[];
+    protected _hideGroupDetails(axis: IRange.Axis, group: IOutline.Group): void;
+    protected _showGroupDetails(axis: IRange.Axis, group: IOutline.Group): void;
+    /** {@inheritDoc IOutline.autoOutline} */
+    autoOutline(options?: ITransaction.OperationOptions): this;
+    /**
+     * The summary lines of one axis within `scope`, and the direction their details lie in.
+     */
+    protected _findSummaries(scope: IRange.Coords, axis: IRange.Axis): {
+        direction: IRange.Direction;
+        spans: SummarySpan[];
+    };
+    protected _groups(axis: IRange.Axis): AxisGroups;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IOutline.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IOutline.toJSON} */
+    toJSON(): IOutline.JSON | null;
+    /**
+     * Stops listening and drops the state. Terminal and not undoable.
+     *
+     * @internal
+     */
+    close(): void;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IOutline.isIOutline} */
+    get isIOutline(): true;
+}
+/**
+ * {@inheritDoc Outline}
+ * @see
+ * ### **Interface**
+ *
+ * {@link Outline}
+ */
+export declare namespace Outline {
+    interface ConstructorOptions {
+        rowHeaders: SheetHeader;
+        columnHeaders: SheetHeader;
+        transactions?: ITransaction.IStore;
+        json?: IOutline.JSON | null;
+    }
+}
+export {};
+//# sourceMappingURL=Outline.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './IOutline';
+//# sourceMappingURL=index.d.ts.map

package/types/src/person/IPerson.d.ts

@@ -0,0 +1,99 @@
+/**
+ * A person known to the workbook: the author of a comment, or someone mentioned in one.
+ *
+ * @remarks
+ * Excel keeps these in a workbook-wide list (`xl/persons/person.xml`) and refers to each by id
+ * from every threaded comment. A legacy note names its author by display name alone; the reader
+ * mints a person for it so both kinds answer {@link IComment.getAuthor} the same way.
+ *
+ * A person is added when a comment names an author the workbook has not seen, and removed with
+ * {@link delete}; a comment whose author was removed answers `null` for them.
+ */
+export interface IPerson {
+    /**
+     * The unique identifier.
+     *
+     * @remarks
+     * A GUID in files Excel wrote; anything unique within the workbook otherwise.
+     */
+    getId(): string;
+    /**
+     * The name shown beside the person's comments.
+     */
+    getDisplayName(): string;
+    /**
+     * The id the person is known by to their identity provider, or `null` if there is none.
+     *
+     * @remarks
+     * Excel keeps an email address here for a person signed in to an organization. Nothing in
+     * SheetXL resolves it.
+     */
+    getUserId(): string | null;
+    /**
+     * The identity provider that vouches for the {@link getUserId | user id}, or `null` if there is
+     * none.
+     *
+     * @remarks
+     * Excel writes `AD` for a directory account, `Windows Live` for a personal one, and `None` for
+     * a name typed with no account behind it.
+     */
+    getProviderId(): string | null;
+    /**
+     * Removes the person from the workbook.
+     *
+     * @remarks
+     * Comments they wrote keep their text and lose their author.
+     */
+    delete(): void;
+    /**
+     * Returns `true` once the person has been removed.
+     */
+    isDeleted(): boolean;
+    /**
+     * @returns The current state as a JSON object.
+     */
+    toJSON(): IPerson.JSON;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIPerson: true;
+}
+/**
+ * {@inheritDoc IPerson}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IPerson}
+ *
+ * **Additional Interfaces**
+ * * {@link IPersonCollection}
+ */
+export declare namespace IPerson {
+    /**
+     * The values that describe a person.
+     */
+    interface Properties {
+        /**
+         * {@inheritDoc IPerson.getDisplayName}
+         */
+        displayName: string;
+        /**
+         * {@inheritDoc IPerson.getUserId}
+         */
+        userId?: string;
+        /**
+         * {@inheritDoc IPerson.getProviderId}
+         */
+        providerId?: string;
+    }
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON extends Properties {
+        /**
+         * {@inheritDoc IPerson.getId}
+         */
+        id: string;
+    }
+}
+//# sourceMappingURL=IPerson.d.ts.map

package/types/src/person/IPersonCollection.d.ts

@@ -0,0 +1,51 @@
+import { ICollection } from '../type';
+import { IPerson } from './IPerson';
+/**
+ * Holds the {@link IPerson | people} a workbook knows: everyone who authored or is mentioned in
+ * a comment.
+ *
+ * @remarks
+ * Keyed by id. Adding a person whose id, or whose display name, is already here returns the
+ * existing one rather than a second copy, which is what lets a legacy note's author (a display
+ * name with no id) and a threaded comment's author (an id) land on one person.
+ */
+export interface IPersonCollection extends ICollection<IPerson> {
+    /**
+     * Adds a person, or returns the one already here with the same id or display name.
+     *
+     * @param person The person's properties, or a display name alone.
+     */
+    add(person: IPerson.Properties | string): IPerson;
+    /**
+     * Returns the person with the given id, or `null` if there is none.
+     */
+    getById(id: string): IPerson | null;
+    /**
+     * Returns the person with the given display name, or `null` if there is none.
+     *
+     * @param displayName The display name. Case sensitive, as Excel keeps it.
+     */
+    getByDisplayName(displayName: string): IPerson | null;
+    /**
+     * The person a new comment is authored by when none is named.
+     *
+     * @remarks
+     * Excel uses the signed-in user; SheetXL has no user, so this is whoever {@link setCurrent}
+     * named, and otherwise a person called `Author`, added on first use.
+     */
+    getCurrent(): IPerson;
+    /**
+     * Names the person new comments are authored by.
+     *
+     * @param person A person, a person's properties, a display name, or `null` to forget the
+     * choice. A person not yet in the collection is added.
+     */
+    setCurrent(person: IPerson | IPerson.Properties | string | null): void;
+    /**
+     * Serializes to JSON, or `null` if there is no one to write.
+     */
+    toJSON(): IPerson.JSON[] | null;
+    /** For runtime type checking. */
+    readonly isIPersonCollection: true;
+}
+//# sourceMappingURL=IPersonCollection.d.ts.map

package/types/src/person/Person.d.ts

@@ -0,0 +1,32 @@
+import { IPerson } from './IPerson';
+/**
+ * Implementation of {@link IPerson}.
+ *
+ * @remarks
+ * Immutable: a person is never edited, only added and removed.
+ */
+export declare class Person implements IPerson {
+    private readonly _json;
+    private readonly _deleteFromCollection;
+    private _deleted;
+    constructor(json: IPerson.JSON, deleteFromCollection?: (person: Person) => void);
+    /** {@inheritDoc IPerson.getId} */
+    getId(): string;
+    /** {@inheritDoc IPerson.getDisplayName} */
+    getDisplayName(): string;
+    /** {@inheritDoc IPerson.getUserId} */
+    getUserId(): string | null;
+    /** {@inheritDoc IPerson.getProviderId} */
+    getProviderId(): string | null;
+    /** {@inheritDoc IPerson.delete} */
+    delete(): void;
+    /** {@inheritDoc IPerson.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc IPerson.toJSON} */
+    toJSON(): IPerson.JSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IPerson.isIPerson} */
+    get isIPerson(): true;
+}
+//# sourceMappingURL=Person.d.ts.map

package/types/src/person/PersonCollection.d.ts

@@ -0,0 +1,49 @@
+import { AbstractCollection } from '../type';
+import { IPerson } from './IPerson';
+import { IPersonCollection } from './IPersonCollection';
+/**
+ * The display name of the person minted when a comment is added and nobody was named.
+ *
+ * @remarks
+ * Data, not UI text: it is written into the file as the author, so it is not localized.
+ */
+export declare const DEFAULT_AUTHOR_NAME = "Author";
+/**
+ * Implementation for {@link IPersonCollection}.
+ *
+ * @remarks
+ * Not transactional: a person is added as a side effect of authoring a comment, and a removal is
+ * not something Excel offers to undo either. Announces `onCollectionChange` on each change.
+ */
+export declare class PersonCollection extends AbstractCollection<IPerson> implements IPersonCollection {
+    private _byId;
+    private _byDisplayName;
+    private _items;
+    private _current;
+    constructor(json?: IPerson.JSON[] | null);
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(): IPerson[];
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IPersonCollection.add} */
+    add(person: IPerson.Properties | string): IPerson;
+    /** {@inheritDoc IPersonCollection.getById} */
+    getById(id: string): IPerson | null;
+    /** {@inheritDoc IPersonCollection.getByDisplayName} */
+    getByDisplayName(displayName: string): IPerson | null;
+    /** {@inheritDoc IPersonCollection.getCurrent} */
+    getCurrent(): IPerson;
+    /** {@inheritDoc IPersonCollection.setCurrent} */
+    setCurrent(person: IPerson | IPerson.Properties | string | null): void;
+    /** @internal */
+    protected _remove(person: IPerson): void;
+    /** {@inheritDoc IPersonCollection.toJSON} */
+    toJSON(): IPerson.JSON[] | null;
+    /**
+     * Loads people from JSON, keeping any already here.
+     */
+    fromJSON(json: IPerson.JSON[] | null | undefined): void;
+    /** {@inheritDoc IPersonCollection.isIPersonCollection} */
+    get isIPersonCollection(): true;
+}
+//# sourceMappingURL=PersonCollection.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './IPerson';
+export * from './IPersonCollection';
+export { PersonCollection } from './PersonCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/picture/IPicture.d.ts

@@ -1,16 +1,38 @@
 import { Size } from '@sheetxl/utils';
 import { IListener } from '../listener';
-import { IResource } from '../resource';
+import { ITransaction } from '../transaction';
+import { IResource, IResourceCollection } from '../resource';
 import { IModel } from '../model';
+import { IMovable } from '../movable';
 /**
  * Interface for working with Pictures (both Images and SVG).
  */
-export interface IPicture extends IModel {
+export interface IPicture extends IModel, IMovable.IContent {
     toJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
+    /**
+     * Deletes the picture, and with it the movable that places it.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * Returns the resource associated with this picture.
      */
     getResource(): IResource;
+    /**
+     * Shows another image, as Excel's Change Picture does: the frame's size and placement and the
+     * picture's formatting stay; only the image changes.
+     *
+     * The resource is taken as it is, not read: a source that cannot be fetched shows nothing. Read
+     * it first (`toBuffer()`) to be sure of it.
+     *
+     * @param picture A url, a resource, or the options to add one with. A url or options take the
+     * sheet's resources, so a picture that is not on a sheet takes a resource.
+     *
+     * @example
+     * ```ts
+     * picture.setResource('https://example.com/logo.png');
+     * ```
+     */
+    setResource(picture: string | IResource | IResourceCollection.AddOptions, options?: ITransaction.OperationOptions): this;
     /**
      * Returns an image blob.
      */
@@ -23,6 +45,8 @@ export interface IPicture extends IModel {
      * Returns a local object URL for placing in an image tag.
      */
     getDetails(): Promise<IPicture.Details>;
+    /** For runtime type checking. */
+    readonly isIPicture: true;
 }
 /**
  * {@inheritDoc IPicture}
@@ -45,6 +69,12 @@ export declare namespace IPicture {
          * The resource id of the picture.
          */
         resId?: number;
+        /**
+         * The id the file gave the picture (`cNvPr/@id`), which a connector's glued ends name it by.
+         * Written again with the file; a picture without one takes the next when a connector first
+         * glues to it.
+         */
+        sourceId?: number;
         effects?: string[];
     }
     interface Details {
@@ -61,7 +91,7 @@ export declare namespace IPicture {
          */
         asSVGText(): string | null;
     }
-    interface Events extends IModel.Events {
+    interface Events extends IMovable.ContentEvents {
     }
     interface IListeners extends IListener.Callbacks<IPicture, IPicture.Events> {
     }

package/types/src/picture/Picture.d.ts

@@ -1,21 +1,42 @@
-import { IResource } from '../resource';
-import { AbstractModel, IModel } from '../model';
+import { ITransaction } from '../transaction';
+import { IResource, IResourceCollection } from '../resource';
+import { IAnchored } from '../anchored';
+import { IMovable } from '../movable/IMovable';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { IPicture } from './IPicture';
-interface State extends AbstractModel.State {
+interface State extends AbstractMovableContent.State {
+    /** The image shown. In the state so that a change of picture undoes with the rest. */
+    resource: IResource;
     effects?: string[];
+    /** The id the file gave the picture; see `IPicture.JSON.sourceId`. */
+    sourceId?: number;
 }
 /**
  * Implementation for {@link IPicture}.
  */
-export declare class Picture extends AbstractModel<State, IPicture.JSON> implements IPicture {
-    private _resource;
+export declare class Picture extends AbstractMovableContent<State, IPicture.JSON> implements IPicture {
+    /** The resource {@link _details} and {@link _dataUrl} were read from; another resource is another read. */
+    private _detailsSource;
     private _details?;
     private _dataUrl?;
     constructor(options: Picture.ConstructorOptions);
     /** {@inheritDoc IPicture.getType} */ getType(): string;
     toJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
     getTypeDescription(): string;
     /** @internal */
+    _getSourceId(): number | undefined;
+    /** @internal */
+    _ensureSourceId(next: () => number): number;
+    /** {@inheritDoc IMovable.IContent.acceptRotation} */
+    acceptRotation(degrees: number): number;
+    /** {@inheritDoc IMovable.IContent.acceptFlip} */
+    acceptFlip(flip: IMovable.Flip): IMovable.Flip;
+    /** {@inheritDoc IMovable.IContent.getDefaultAnchorType} */
+    getDefaultAnchorType(): IAnchored.Type;
+    /** {@inheritDoc IMovable.IContent.isDefaultLockAspectRatio} */
+    isDefaultLockAspectRatio(): boolean;
+    /** @internal */
     protected _asDataUrl(): Promise<string>;
     /** {@inheritDoc IPicture.toHtml} */
     toHtml(): Promise<string> | string | null;
@@ -25,6 +46,10 @@ export declare class Picture extends AbstractModel<State, IPicture.JSON> impleme
     toArrayBuffer(): Promise<ArrayBuffer>;
     /** {@inheritDoc IPicture.getResource} */
     getResource(): IResource;
+    /** {@inheritDoc IPicture.setResource} */
+    setResource(picture: string | IResource | IResourceCollection.AddOptions, options?: ITransaction.OperationOptions): this;
+    /** The resource shown, dropping what was read from another one. */
+    private _readFrom;
     /** {@inheritDoc IPicture.getDetails} */
     getDetails(): Promise<IPicture.Details>;
     /** @internal */
@@ -35,6 +60,8 @@ export declare class Picture extends AbstractModel<State, IPicture.JSON> impleme
     protected _toDrawingJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
     /** @internal */
     protected _processDelete(): void;
+    /** {@inheritDoc IPicture.isIPicture} */
+    get isIPicture(): true;
 }
 /**
  * Interfaces for creating `Picture` items.
@@ -48,19 +75,12 @@ export declare namespace Picture {
     /**
      * Options for creating an IPicture.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<IPicture.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<IPicture.JSON> {
         resource?: IResource;
         /**
          * Returns an IResource from the resourceId or null if not found.
          */
         fromResourceId?: (resourceId: number) => IResource;
-        /**
-         * Useful for load/save/copying.
-         */
-        /**
-         * Allow for the default lock aspect ratio to be overwritten.
-         */
-        defaultLockAspectRatio?: boolean;
     }
 }
 export {};

package/types/src/pivot/IPivotTable.d.ts

@@ -0,0 +1,72 @@
+import { IResource } from '../resource';
+import { ISheet } from '../sheet';
+import { ICellRange } from '../cellRange';
+import { IAnchored } from '../anchored';
+import { IEmbeddedPart } from '../io';
+/**
+ * A pivot table laid out on a sheet: the part it was read from, anchored at its location.
+ *
+ * @remarks
+ * The table is not modeled yet beyond where it sits and what it summarizes: its markup is kept
+ * as read and written back as read, with the location restated. Where it sits follows
+ * structural edits as a table's range does; an edit that would move only part of it is refused,
+ * as Excel refuses it, and one that takes every cell of it deletes it.
+ */
+export interface IPivotTable extends IAnchored {
+    toJSON(toResourceId?: (resource: IResource) => number | null): IPivotTable.JSON | null;
+    /**
+     * Returns the name, unique across the workbook as Excel keeps it.
+     */
+    getName(): string;
+    /**
+     * Returns the sheet the table is laid out on.
+     */
+    getSheet(): ISheet;
+    /**
+     * Returns the cells the table is laid out on.
+     *
+     * @remarks
+     * The anchor: an insert or delete before the table moves it, one taking every cell of it
+     * deletes it ({@link IAnchored.isDeleted}), and one that would move part of it - a row deleted
+     * or inserted inside it, a column cut through it - is refused.
+     */
+    getRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /**
+     * Returns the markup of the table's part, with the location as it is now.
+     */
+    getXML(): string | null;
+    /**
+     * Returns the id of the cache this table summarizes.
+     *
+     * @remarks
+     * The cache is the workbook's, written once and referenced from each table by id.
+     *
+     * @internal
+     */
+    getCacheId(): number;
+    /** For runtime type checking. */
+    readonly isIPivotTable: true;
+}
+export declare namespace IPivotTable {
+    /**
+     * A pivot cache as the workbook carries it: the part, by the id the tables name.
+     */
+    interface CacheJSON {
+        cacheId: number;
+        part?: IEmbeddedPart.JSON;
+    }
+    /**
+     * JSON representation of a pivot table.
+     */
+    interface JSON {
+        name?: string;
+        cacheId: number;
+        part?: IEmbeddedPart.JSON;
+    }
+    /**
+     * `Events` for {@link IPivotTable}.
+     */
+    interface Events extends IAnchored.Events<IPivotTable> {
+    }
+}
+//# sourceMappingURL=IPivotTable.d.ts.map

package/types/src/pivot/IPivotTableCollection.d.ts

@@ -0,0 +1,25 @@
+import { ICollection } from '../type';
+import { IPivotTable } from './IPivotTable';
+/**
+ * Holds {@link IPivotTable | pivot tables} — a sheet's, or every sheet's in the workbook.
+ *
+ * @remarks
+ * Read-only for now: a table is carried as it was read and written back unchanged. Adding,
+ * deleting and refreshing wait on the table having a model of its own.
+ */
+export interface IPivotTableCollection extends ICollection<IPivotTable> {
+    /**
+     * Returns the pivot tables, in the order they were read; the workbook's walks its sheets in
+     * sheet order.
+     */
+    getItems(options?: ICollection.GetItemsOptions): IPivotTable[];
+    /**
+     * Returns the pivot table with the given name, or `null` if there is none.
+     *
+     * @param name The name of the pivot table. This is case insensitive.
+     */
+    getByName(name: string): IPivotTable | null;
+    /** For runtime type checking. */
+    readonly isIPivotTableCollection: true;
+}
+//# sourceMappingURL=IPivotTableCollection.d.ts.map