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

package/types/src/workbook/Workbook.d.ts

@@ -4,20 +4,28 @@ import { IListener } from '../listener';
 import { INamedCollection } from '../named';
 import { IExternalBookCollection } from '../externalBook';
 import { NamedTableSource } from '../table/_NamedTableSource';
+import { IPivotTableCollection } from '../pivot';
+import { IEmbeddedPart } from '../io/IEmbeddedPart';
+import { PivotCache } from '../pivot/PivotCache';
+import { ICommentCollection } from '../comment';
+import { IPersonCollection } from '../person';
 import { ICalculation } from '../calculation';
-import { IScript, IModule } from '../scripting';
+import { IFontCollection } from '../font/IFontCollection';
+import { IScript, IModule, IModuleCollection } from '../scripting';
 import { IResourceCollection } from '../resource';
 import { IStringCollection } from '../string';
 import { ITheme } from '../theme';
 import { ICell } from '../cell';
-import { ICellRange, ICellRanges } from '../cellRange';
+import { ICellRange, ICellRanges, ICellRegions } from '../cellRange';
 import { IStyleCollection } from '../style';
-import { ISheet, ISheetCollection } from '../sheet';
+import { ISheet, IWorksheet, IOpaqueSheet, IWorksheetCollection } from '../sheet';
 import { IWorkbookView } from '../workbookView';
 import { IWorkbookProtection } from '../workbookProtection';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 import { WorkbookProtection } from '../workbookProtection/WorkbookProtection';
-import { _NamedGraphNode } from '../cellRange/_GraphNode';
+import { IDocumentProperties } from '../documentProperties';
+import { DocumentProperties } from '../documentProperties/DocumentProperties';
+import { NamedNodeInfo } from '../calculation/Types';
 import { IWorkbookIO } from '../io/IWorkbookIO';
 import { IWorkbook } from './IWorkbook';
 /**
@@ -28,13 +36,20 @@ export declare class Workbook implements IWorkbook {
     protected _id: string;
     protected _createSheet: InternalCreateSheet;
     protected _createSheetName: (id: number) => string;
+    /** `true` while the sheets of the constructor's `json` are being created. */
+    protected _isLoadingSheets: boolean;
     protected _transactions: ITransaction.IStore;
     protected _ownTransactions: boolean;
     protected _transactionsRemoveListener: IListener.Remove;
     protected _lastTransactionUUID: string | null;
     protected _starting: Promise<void> | null;
     protected _closed: boolean;
-    /** Stable, read-only reference to the IO-owned origin handle. See {@link IWorkbook.getOrigin}. */
+    /** Supplies the origin the workbook lives in now. See {@link IWorkbook.getOrigin}. */
+    protected _originProvider: IWorkbookIO.OriginProvider;
+    /** `true` when the workbook made its provider (and so releases it on close); `false` for a host's. */
+    protected _ownOriginProvider: boolean;
+    protected _listenerOriginProvider: IListener.Remove | null;
+    /** The origin currently followed for renames — the provider's, as of its last change. */
     protected _origin: IWorkbookIO.Origin;
     protected _listenerOrigin: IListener.Remove | null;
     /** Last derived display name, so stat-style origin changes (size) don't fire onNameChange. */
@@ -45,7 +60,25 @@ export declare class Workbook implements IWorkbook {
     protected _theme: ITheme;
     protected _strings: IStringCollection;
     protected _ownStrings: boolean;
-    protected _externalBooks: IExternalBookCollection;
+    /**
+     * The pivot caches, held as read until they have a model of their own. Not workbook state:
+     * nothing edits them, so they neither transact nor notify.
+     */
+    /**
+     * The workbook's pivot caches, by the id its tables reference them by.
+     *
+     * @remarks
+     * Carried, not modeled — see {@link IPivotTable.CacheJSON}. Held in part form rather than as
+     * the JSON it was read from because the resources a part can carry are model references, and
+     * their ids are assigned per save.
+     */
+    protected _pivotCaches: PivotCache[];
+    /** Every sheet's pivot tables, in sheet order — a walk, not a second store. */
+    protected _pivotTableCollection: IPivotTableCollection;
+    /** The people the workbook knows — comment authors. Not workbook state: never undone. */
+    protected _people: IPersonCollection;
+    /** Every sheet's comments, in sheet order — a walk, not a second store. */
+    protected _commentCollection: ICommentCollection;
     protected _styles: IStyleCollection;
     protected _ownStyles: boolean;
     protected _resources: IResourceCollection;
@@ -65,7 +98,7 @@ export declare class Workbook implements IWorkbook {
     protected _ownCalculation: boolean;
     protected _view: IWorkbookView;
     protected _activeSheetOffset: number;
-    protected _sheets: ISheetCollection;
+    protected _sheets: IWorksheetCollection;
     protected _sheetOnNameChange: Map<number, () => void>;
     protected _sheetOnVisibilityChange: Map<number, () => void>;
     protected _sheetOnIndexChange: Map<number, () => void>;
@@ -76,13 +109,19 @@ export declare class Workbook implements IWorkbook {
     protected _listenerLanguage: IListener.Remove;
     protected _runtime: IRuntime;
     protected _isDate1904: boolean;
+    /** VBA binding identity; carried from the file, never minted. See {@link IWorkbook.getCodeName}. */
+    protected _codeName: string | null;
+    /** Carried, not obeyed — see {@link IWorkbook.JSON.updateLinks}. `null` when the source said nothing. */
+    protected _updateLinks: IExternalBookCollection.UpdateLinks | null;
+    /** See {@link IWorkbook.getProperties}. */
+    protected _documentProperties: DocumentProperties;
     /** `null` follows the environment locale. */
     protected _locale: string | null;
     /** Literal patch over the derived {@link LocaleProfile} (regional-override escape hatch); `null` = none. */
     protected _localeOverrides: LocaleProfileOverrides | null;
     constructor(options?: IWorkbook.ConstructorOptions | string);
     protected _initState(): void;
-    /** {@inheritDoc ISheet.getId} */
+    /** {@inheritDoc IWorksheet.getId} */
     getId(): string;
     /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
     getVersionId(): number;
@@ -90,6 +129,17 @@ export declare class Workbook implements IWorkbook {
     getName(): string | null;
     /** {@inheritDoc IWorkbook.getOrigin} */
     getOrigin(): IWorkbookIO.Origin;
+    /**
+     * The provider moved the workbook to another origin: follow the new one instead of the old, and
+     * say so. Non-transactional — where a workbook lives is not a model edit.
+     */
+    private _onOriginChange;
+    /**
+     * Holds `origin` and follows it: the display name derives from the origin, so a change to it (a
+     * rename) IS a name change — but only when the *derived name* changed, since the handle also
+     * updates on stat-style changes (size on every save) that must not fire spurious name events.
+     */
+    private _bindOrigin;
     /** {@inheritDoc IWorkbook.getView} */
     getView(): IWorkbookView;
     /** {@inheritDoc IWorkbook.setView} */
@@ -114,10 +164,22 @@ export declare class Workbook implements IWorkbook {
     getResources(): IResourceCollection;
     /** {@inheritDoc IWorkbook.getTransactions} */
     getTransactions(): ITransaction.IStore;
+    /** {@inheritDoc IWorkbook.getChanges} */
+    getChanges(commitId?: string): IWorksheet.ChangeEvent[];
     /** {@inheritDoc IWorkbook.getStrings} */
     getStrings(): IStringCollection;
     /** {@inheritDoc IWorkbook.getExternalBooks} */
     getExternalBooks(): IExternalBookCollection;
+    /** {@inheritDoc IWorkbook.getUpdateLinks} */
+    getUpdateLinks(): IExternalBookCollection.UpdateLinks | null;
+    /** {@inheritDoc IWorkbook.setUpdateLinks} */
+    setUpdateLinks(updateLinks: IExternalBookCollection.UpdateLinks | null): this;
+    /** {@inheritDoc IWorkbook.getPivotTables} */
+    getPivotTables(): IPivotTableCollection;
+    /** {@inheritDoc IWorkbook.getComments} */
+    getComments(): ICommentCollection;
+    /** {@inheritDoc IWorkbook.getPeople} */
+    getPeople(): IPersonCollection;
     /** {@inheritDoc IWorkbook.getTheme} */
     getTheme(): ITheme;
     /** {@inheritDoc IWorkbook.setTheme} */
@@ -126,15 +188,38 @@ export declare class Workbook implements IWorkbook {
     getSelectedSheetIndex(): number;
     /** {@inheritDoc IWorkbook.getSelectedSheet} */
     getSelectedSheet(): ISheet;
-    /** {@inheritDoc IWorkbook.getSheet} */
-    getSheet(name?: string, visibility?: ISheet.Visibility): ISheet;
-    /** {@inheritDoc IWorkbook.getSheetAt} */
-    getSheetAt(index: number, visibility?: ISheet.Visibility): ISheet;
+    /** {@inheritDoc IWorkbook.getSelectedWorksheet} */
+    getSelectedWorksheet(): IWorksheet | null;
+    /** {@inheritDoc IWorkbook.getActiveSheet} */
+    getActiveSheet(): IWorksheet | null;
+    /** {@inheritDoc IWorkbook.getActiveWorksheet} */
+    getActiveWorksheet(): IWorksheet | null;
     /** {@inheritDoc IWorkbook.getSheets} */
-    getSheets(): ISheetCollection;
-    /** {@inheritDoc IWorkbook.addSheet} */
-    addSheet(options?: ISheetCollection.AddOptions | string | number): ISheet;
-    protected _getSheets(visibility?: ISheet.Visibility): ISheet[];
+    getSheets(options?: IWorkbook.GetSheetsOptions): ISheet[];
+    /** {@inheritDoc IWorkbook.getSheet} */
+    getSheet(name?: string): ISheet;
+    /** {@inheritDoc IWorkbook.getWorksheet} */
+    getWorksheet(name?: string | number, visibility?: ISheet.Visibility): IWorksheet;
+    /** {@inheritDoc IWorkbook.getWorksheetAt} */
+    getWorksheetAt(index: number, visibility?: ISheet.Visibility): IWorksheet;
+    /**
+     * The selected worksheet, or a throw naming the selected tab when that is another kind: for the
+     * callers that act on "the sheet" unqualified, where `null` has nowhere to go.
+     * @internal
+     */
+    protected _requireSelectedWorksheet(): IWorksheet;
+    /**
+     * The worksheet that internal plumbing anchors unqualified coords to: the selected one, or else
+     * the first in tab order, or `null` when the workbook has none.
+     * @internal
+     */
+    protected _anchorWorksheet(): IWorksheet | null;
+    /** {@inheritDoc IWorkbook.getWorksheets} */
+    getWorksheets(): IWorksheetCollection;
+    /** {@inheritDoc IWorkbook.addWorksheet} */
+    addWorksheet(options?: IWorksheetCollection.AddOptions | string | number): IWorksheet;
+    /** The worksheets in tab order, no other kind. */
+    protected _getWorksheets(visibility?: ISheet.Visibility): IWorksheet[];
     protected _getSheetRefs(visibility?: ISheet.Visibility): SheetRef[];
     /** @internal */
     protected _getSheetRef(key: SheetKey | null | undefined, visibility?: ISheet.Visibility): SheetRef | null | undefined;
@@ -144,16 +229,59 @@ export declare class Workbook implements IWorkbook {
     findValidSheetName(str: string): string;
     /** {@inheritDoc IWorkbook.isValidSheetNameCharacter} */
     isValidSheetNameCharacter(character: string): boolean;
+    /**
+     * Whether structure protection refuses an edit now. Never while loading: opening a protected
+     * workbook is not an edit.
+     * @internal
+     */
+    _isStructureProtected(): boolean;
     /** @internal */
-    protected _addSheetOptions(options?: ISheetCollection.AddOptions | string | number): ISheet;
+    protected _addSheetOptions(options?: IWorksheetCollection.AddOptions | string | number): IWorksheet;
     /** @internal */
     protected _nextSheetName(sheetName?: string | null | undefined): string;
     /** @internal */
-    protected _addSheet(notify: boolean, sheetName?: string | null, index?: number | null): ISheet;
+    protected _addSheet(notify: boolean, sheetName?: string | null, index?: number | null, uid?: string): IWorksheet;
+    /**
+     * Builds a sheet that is carried rather than modeled and adds its ref, as `_createSheet` does
+     * for a worksheet.
+     * @internal
+     */
+    protected _createOpaqueSheet(id: number, name: string, visibility: ISheet.Visibility, index: number | null, sheetId: number | undefined, kind: IOpaqueSheet.Kind, part: IEmbeddedPart, tabColor: string | null, uid?: string): IOpaqueSheet;
+    /**
+     * Makes `sheet` the active tab and asks the host to bring it to the front.
+     * @internal
+     */
+    protected _requestSelect(sheet: ISheet): Promise<boolean>;
     /** @internal */
     protected _updateSheetRefStates(sheetRefs: SheetRef[]): void;
+    /**
+     * Tells the calculation the sheet list as it is: every sheet, hidden ones included, in tab
+     * order. Called where an operation on the list completes - beside its `onSheetsChange`, or in
+     * `_updateSheetRef` for a ref replaced - and, for a sheet being added, once its ref is in, before
+     * its grid seeds. Never on a restore: the calculation's copy is restored with this one. A load
+     * tells the whole list before its first sheet, so a part of it is not told while the load builds
+     * them.
+     */
+    protected _tellSheets(): void;
     /** @internal */
     protected _addSheetRef(sheetRefAdd: SheetRef, index?: number | null): SheetRef;
+    /**
+     * Record which sheet was active before the operation and which it leaves active. See
+     * {@link ActiveSheetIntent} for how a batch merges the pair.
+     *
+     * @internal
+     */
+    protected _recordActiveSheet(trans: ITransaction, before: number | null, after: number | null): void;
+    /**
+     * Point the view at `targetId`, or, when `state` no longer shows that sheet, at the sheet
+     * now in the active sheet's place (the last one when it was at the end).
+     *
+     * @remarks
+     * The view listener recomputes the offset when the id changes; when it does not, the sheet
+     * may still have moved, so the offset is recomputed here.
+     * @internal
+     */
+    protected _resyncActiveSheet(targetId: number | null | undefined, state: State): void;
     /** @internal */
     protected _adjustRemoveSelectionIfRequired(indexRemove: number, id: number | null | undefined): void;
     /** @internal */
@@ -170,12 +298,18 @@ export declare class Workbook implements IWorkbook {
     protected _nextSheetIndex(index: number, refs?: SheetRef[]): number;
     /** @internal */
     protected _prevSheetIndex(index: number, refs?: SheetRef[]): number;
+    /**
+     * The position in `worksheets` of the visible tab at `tabOffset`, or of the first worksheet after
+     * it when that tab is another kind.
+     * @internal
+     */
+    protected _worksheetOffsetFrom(tabOffset: number, worksheets: readonly IWorksheet[]): number;
     /** {@inheritDoc IWorkbook.getNextSheet} */
     getNextSheet(index: number): ISheet;
     /** {@inheritDoc IWorkbook.getPreviousSheet} */
     getPreviousSheet(index: number): ISheet;
     /** @internal */
-    protected _duplicateSheet(key?: SheetKey | null): Promise<ISheet | null>;
+    protected _duplicateSheet(key?: SheetKey | null): Promise<IWorksheet | null>;
     /** @internal */
     protected _createRange(coords: IRange.FixableCoords, getOptions?: ICellRange.GetRangeOptions): ICellRange;
     /** @internal */
@@ -196,7 +330,9 @@ export declare class Workbook implements IWorkbook {
      * resolved falls back to the selected sheet, which is the same self-consistent-but-arbitrary
      * anchor its body was compiled against. Names lead, cells follow — the name is the heavier fact.
      */
-    protected _createGraphRanges(cells: readonly IRange.Coords[], names: readonly _NamedGraphNode[]): ICellRanges | null;
+    protected _createGraphRanges(cells: readonly IRange.Coords[], names: readonly NamedNodeInfo[]): ICellRanges | null;
+    /** {@inheritDoc IWorkbook.getAnomalies} */
+    getAnomalies(options?: ICellRange.GetAnomaliesOptions): ICellRegions;
     /** {@inheritDoc IWorkbook.getStats} */
     getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
     /** @internal */
@@ -229,38 +365,56 @@ export declare class Workbook implements IWorkbook {
     protected _setSelectedSheet(key: SheetKey | null): ISheet;
     /** {@inheritDoc IWorkbook.getProtection} */
     getProtection(): IWorkbookProtection;
+    /** {@inheritDoc IWorkbook.getProperties} */
+    getProperties(): IDocumentProperties;
+    /** {@inheritDoc IWorkbook.getCodeName} */
+    getCodeName(): string | null;
     /** {@inheritDoc IWorkbook.getNames} */
     getNames(): INamedCollection;
     /** {@inheritDoc IWorkbook.getCalculation} */
     getCalculation(): ICalculation;
+    /** {@inheritDoc IWorkbook.getFonts} */
+    getFonts(): IFontCollection;
     /** {@inheritDoc IWorkbook.createFormula} */
-    createFormula(expression: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula;
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>, options?: ICalculation.CreateFormulaOptions): ICalculation.IFormula;
     /** {@inheritDoc IWorkbook.evaluate} */
-    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords>): Promise<Scalar | IRange>;
+    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords> & ICalculation.CreateFormulaOptions): Promise<Scalar | IRange>;
     /** {@inheritDoc IWorkbook.whenCalculationReady} */
     whenCalculationReady(): Promise<ICalculation.Status>;
+    /** {@inheritDoc IWorkbook.whenFontsReady} */
+    whenFontsReady(): Promise<void>;
+    /** {@inheritDoc IWorkbook.whenReady} */
+    whenReady(): Promise<void>;
     /** {@inheritDoc IWorkbook.getScripts} */
     getScripts(): IScript;
+    /** {@inheritDoc IWorkbook.getModules} */
+    getModules(): IModuleCollection;
     /** @internal */
     protected _notifyAllChange(): void;
     /** {@inheritDoc IWorkbook.addListeners} */
     addListeners(listeners: IWorkbook.IListeners, options?: IListener.Options): IListener.Remove;
     /** @internal */
     protected _sheetToWBEvent(listenerWB: ICellRange.Listener): ICellRange.Listener;
+    /**
+     * Each pivot cache's source is held through the sheet it names, once the sheets exist, so an
+     * insert above the source moves it (see `PivotCache`).
+     * @internal
+     */
+    protected _holdPivotCaches(): void;
     /** @internal */
-    protected _fromJSON(json: IWorkbook.JSON): void;
+    protected _fromJSON(json: IWorkbook.JSON, uids?: readonly string[]): void;
     /** @internal */
     protected _createScripts(json?: Record<string, IModule.JSON>): IScript;
     /** {@inheritDoc IWorkbook.toJSON} */
-    toJSON(options?: ISheet.ToJSONOptions): Promise<IWorkbook.JSON>;
+    toJSON(options?: IWorksheet.ToJSONOptions): Promise<IWorkbook.JSON>;
     /** {@inheritDoc IWorkbook.isClosed} */
     isClosed(): boolean;
     /** {@inheritDoc IWorkbook.close} */
     close(): void;
     /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
     beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
-    /** {@inheritDoc ITransaction.ITransactional.doBatch} */
-    doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
+    /** {@inheritDoc IWorkbook.doBatch} */
+    doBatch<R>(callback: (commit: ITransaction.ICommit, workbook: this) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
     /** @internal */
     protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
     /** @internal */
@@ -294,7 +448,12 @@ interface SheetRef {
      */
     visibility: ISheet.Visibility;
     /**
-     * The sheet model
+     * The origin format's identifier for the sheet, carried through untouched.
+     * See {@link IWorkbook.SheetRefJSON.sheetId} — interop only, never {@link SheetRef.id}.
+     */
+    sheetId?: number;
+    /**
+     * The sheet model, of any kind.
      */
     sheet: ISheet;
 }
@@ -333,10 +492,19 @@ interface InternalCreateSheet {
      * @defaultValue - End of sheets
      */
     index: number | null, 
+    /**
+     * The origin format's identifier for the sheet, if it came from one.
+     * @internal
+     */
+    sheetId: number | undefined, 
     /**
      * The JSON representation of the sheet.
      */
-    json: ISheet.JSON | null | undefined): ISheet;
+    json: IWorksheet.JSON | null | undefined, 
+    /**
+     * The sheet's id ({@link IWorksheet.getId}), when the workbook named it before building it.
+     */
+    uid?: string): IWorksheet;
 }
 export {};
 //# sourceMappingURL=Workbook.d.ts.map

package/types/src/workbook/WorkbookRange.d.ts

@@ -3,7 +3,7 @@ import { IListener } from '../listener';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { IWorkbook } from './IWorkbook';
 import { SheetRange, SheetRangeOptions } from '../sheet/SheetRange';
-import { ISheetInternal } from '../sheet/Sheet';
+import { IWorksheetInternal } from '../sheet/Worksheet';
 export interface WorkbookRangeOptions extends SheetRangeOptions {
 }
 /**
@@ -11,7 +11,7 @@ export interface WorkbookRangeOptions extends SheetRangeOptions {
  */
 export declare class WorkbookRange extends SheetRange implements ICellRange {
     protected _workbook: IWorkbook;
-    constructor(coords: IRange.FixableCoords, internal: ISheetInternal, workbook: IWorkbook, options: WorkbookRangeOptions | null | undefined);
+    constructor(coords: IRange.FixableCoords, internal: IWorksheetInternal, workbook: IWorkbook, options: WorkbookRangeOptions | null | undefined);
     protected _createRanges(coords: readonly IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): ICellRanges;
     protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): this;
     /** {@inheritDoc ICellRange.addListener} */

package/types/src/workbook/WorkbookRanges.d.ts

@@ -3,7 +3,7 @@ import { IListener } from '../listener';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { IWorkbook } from './IWorkbook';
 import { SheetRanges, SheetRangesOptions } from '../sheet/SheetRanges';
-import { ISheetInternal } from '../sheet/Sheet';
+import { IWorksheetInternal } from '../sheet/Worksheet';
 export interface WorkbookRangesOptions extends SheetRangesOptions {
 }
 /**
@@ -11,7 +11,7 @@ export interface WorkbookRangesOptions extends SheetRangesOptions {
  */
 export declare class WorkbookRanges extends SheetRanges implements ICellRanges {
     protected _workbook: IWorkbook;
-    constructor(coords: readonly (IRange.FixableCoords | ICellRange)[], internal: ISheetInternal, workbook: IWorkbook, options: WorkbookRangesOptions | null | undefined);
+    constructor(coords: readonly (IRange.FixableCoords | ICellRange)[], internal: IWorksheetInternal, workbook: IWorkbook, options: WorkbookRangesOptions | null | undefined);
     /** {@inheritDoc ICellRange.getSource} */
     getSource<S>(): S;
     protected _createRanges(coords: readonly IRange.Coords[], getOptions?: ICellRange.GetRangeOptions): this;

package/types/src/workbook/_WorkbookIntents.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Directives a workbook operation records on its transaction: something to do once the operation
+ * completes, rather than a change the operation makes.
+ *
+ * @remarks
+ * Ids and options - no workbook, sheet or view instances. See `_SheetIntents` for the sheet's
+ * half of the same model.
+ *
+ * @internal
+ */
+/** Key for the {@link ActiveSheetIntent}. */
+export declare const IntentActiveSheet = "workbook.activeSheet";
+/**
+ * Which sheet is active before and after the operation.
+ *
+ * @remarks
+ * The view is not transactional, so a landed state and the view can disagree about the active
+ * sheet: adding a sheet selects it, and an undo has to put the user back on the one they were on.
+ * Merged the way the sheet's pairs are - `before` first-writer-wins, `after` last-writer-wins -
+ * so a batch undoes to the sheet it began on and redoes to the one it ended on.
+ */
+export interface ActiveSheetIntent {
+    /**
+     * {@link IWorkbookView.getId} of the view the operation was made against.
+     *
+     * @remarks
+     * A workbook can be shown through more than one view - each user in a shared workbook has their
+     * own - and only the view that made the change is moved by undoing it.
+     */
+    viewId: string;
+    /** {@link IWorksheet.getId} of the sheet that was active when the operation began. */
+    before?: number | null;
+    /** {@link IWorksheet.getId} of the sheet the operation leaves active. */
+    after?: number | null;
+}
+//# sourceMappingURL=_WorkbookIntents.d.ts.map

package/types/src/workbook/_WorkbookMessages.d.ts

@@ -5,4 +5,9 @@ export declare function ERROR_DELETE_KEY(key: string): string;
 export declare function ERROR_SHEET_NAME_NOT_FOUND(sheetName: string): string;
 export declare function ERROR_SHEET_INDEX_NOT_FOUND(index: number): string;
 export declare function ERROR_SHEET_NAME_INVALID_CHARS(sheetName?: string): string;
+/** A named sheet that is not a worksheet, where a worksheet is required. */
+export declare function ERROR_SHEET_NOT_WORKSHEET(sheetName: string, kind: string): string;
+/** The selected tab is not a worksheet, where "the sheet" unqualified must be one. */
+export declare function ERROR_SELECTED_NOT_WORKSHEET(sheetName: string, kind: string): string;
+export declare function ERROR_SHEET_NOT_DUPLICABLE(sheetName: string): string;
 //# sourceMappingURL=_WorkbookMessages.d.ts.map

package/types/src/workbookProtection/IWorkbookProtection.d.ts

@@ -26,6 +26,8 @@ export interface IWorkbookProtection extends IProtection<IWorkbookProtection, IW
      * @returns `true` if revisions are locked, `false` otherwise.
      */
     isRevisionAllowed(): boolean;
+    /** For runtime type checking. */
+    readonly isIWorkbookProtection: true;
 }
 /**
  * {@inheritDoc IWorkbookProtection}
@@ -48,6 +50,11 @@ export declare namespace IWorkbookProtection {
         revision?: boolean;
     }
     interface JSON extends IProtection.JSON {
+        /**
+         * `true` when the whole workbook stays allowed: it is not protected, and keeps its options for
+         * the next lock. Absent, the workbook is protected.
+         */
+        workbook?: boolean;
         revisionsPassword?: Partial<IProtection.EncryptedPassword>;
         structure?: boolean;
         windows?: boolean;

package/types/src/workbookProtection/WorkbookProtection.d.ts

@@ -7,8 +7,11 @@ export declare class WorkbookProtection extends DefaultProtection<IWorkbookProte
     isRevisionAllowed(): boolean;
     /** {@inheritDoc IWorkbookProtection.isStructureAllowed} */
     isStructureAllowed(): boolean;
+    protected _getAllowedKey(): string;
     protected _fromJSON(json: IWorkbookProtection.JSON | null): void;
     protected _toJSON(json: IWorkbookProtection.JSON): IWorkbookProtection.JSON;
     get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IWorkbookProtection.isIWorkbookProtection} */
+    get isIWorkbookProtection(): true;
 }
 //# sourceMappingURL=WorkbookProtection.d.ts.map

package/types/src/workbookView/IWorkbookView.d.ts

@@ -4,6 +4,16 @@ import { IListener } from '../listener';
  *
  */
 export interface IWorkbookView {
+    /**
+     * Identifies this view.
+     *
+     * @remarks
+     * Stable for the life of the view. A workbook can be shown through more than one view — each
+     * user in a shared workbook has their own — so anything recorded against a view (the active
+     * sheet an undo returns to, for example) names it by this id rather than holding the view
+     * itself.
+     */
+    getId(): string;
     /**
      * Shows the visibility of the formula bar.
      */
@@ -64,6 +74,57 @@ export interface IWorkbookView {
      * @see {@link IWorkbookView.setShowStatusBar}
      */
     isShowStatusBar(): boolean;
+    /**
+     * The first sheet tab shown in the tab strip, by sheet index: how far the tabs are scrolled.
+     *
+     * @defaultValue 0
+     */
+    setFirstTab(newValue: number): this;
+    /**
+     * @see {@link IWorkbookView.setFirstTab}
+     */
+    getFirstTab(): number;
+    /**
+     * Where the workbook's window sits on the screen, in twips (a twentieth of a point).
+     *
+     * @defaultValue `null` (the application places it)
+     */
+    setWindowBounds(newValue: IWorkbookView.WindowBounds | null): this;
+    /**
+     * @see {@link IWorkbookView.setWindowBounds}
+     */
+    getWindowBounds(): IWorkbookView.WindowBounds | null;
+    /**
+     * Whether the workbook's window is minimized.
+     *
+     * @defaultValue false
+     */
+    setMinimized(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setMinimized}
+     */
+    isMinimized(): boolean;
+    /**
+     * Whether the workbook's window is shown. A hidden window is how Excel keeps a workbook open
+     * out of sight, as its personal macro workbook does.
+     *
+     * @defaultValue {@link IWorkbookView.Visibility.Visible}
+     */
+    setVisibility(newValue: IWorkbookView.Visibility): this;
+    /**
+     * @see {@link IWorkbookView.setVisibility}
+     */
+    getVisibility(): IWorkbookView.Visibility;
+    /**
+     * Whether a filter's list groups dates by year, month and day.
+     *
+     * @defaultValue true
+     */
+    setAutoFilterDateGrouping(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setAutoFilterDateGrouping}
+     */
+    isAutoFilterDateGrouping(): boolean;
     /**
      * The id of of the activeSheet.
      *
@@ -87,6 +148,8 @@ export interface IWorkbookView {
      * Saves the current state to JSON.
      */
     toJSON(): IWorkbookView.JSON | null;
+    /** For runtime type checking. */
+    readonly isIWorkbookView: true;
 }
 /**
  * {@inheritDoc IWorkbookView}
@@ -127,7 +190,38 @@ export declare namespace IWorkbookView {
         showStatusBar?: boolean;
         /** {@inheritDoc IWorkbookView.setActiveSheetId} */
         activeSheetId?: number | null;
+        /** {@inheritDoc IWorkbookView.setFirstTab} */
+        firstTab?: number;
+        /** {@inheritDoc IWorkbookView.setWindowBounds} */
+        windowBounds?: IWorkbookView.WindowBounds | null;
+        /** {@inheritDoc IWorkbookView.setMinimized} */
+        minimized?: boolean;
+        /** {@inheritDoc IWorkbookView.setVisibility} */
+        visibility?: IWorkbookView.Visibility;
+        /** {@inheritDoc IWorkbookView.setAutoFilterDateGrouping} */
+        autoFilterDateGrouping?: boolean;
+    }
+    /**
+     * A window's position and size, in twips (a twentieth of a point).
+     */
+    interface WindowBounds {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
     }
+    /**
+     * Whether a workbook's window is shown.
+     */
+    const Visibility: {
+        /** Shown. */
+        readonly Visible: "visible";
+        /** Hidden; the user can unhide it. */
+        readonly Hidden: "hidden";
+        /** Hidden, and not offered to the user to unhide. */
+        readonly VeryHidden: "veryHidden";
+    };
+    type Visibility = typeof Visibility[keyof typeof Visibility];
     interface JSON extends Properties {
     }
 }