@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

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

@@ -0,0 +1,342 @@
+import { Scalar, IRange, IRangeStats, IRuntime, LocaleProfileOverrides } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { INamedCollection } from '../named';
+import { IExternalBookCollection } from '../externalBook';
+import { NamedTableSource } from '../table/_NamedTableSource';
+import { ICalculation } from '../calculation';
+import { IScript, IModule } from '../scripting';
+import { IResourceCollection } from '../resource';
+import { IStringCollection } from '../string';
+import { ITheme } from '../theme';
+import { ICell } from '../cell';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IStyleCollection } from '../style';
+import { ISheet, ISheetCollection } 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 { IWorkbookIO } from '../io/IWorkbookIO';
+import { IWorkbook } from './IWorkbook';
+/**
+ * The Base implementation of {@link IWorkbook}.
+ */
+export declare class Workbook implements IWorkbook {
+    protected _options: IWorkbook.ConstructorOptions;
+    protected _id: string;
+    protected _createSheet: InternalCreateSheet;
+    protected _createSheetName: (id: number) => string;
+    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}. */
+    protected _origin: IWorkbookIO.Origin;
+    protected _listenerOrigin: IListener.Remove | null;
+    /** Last derived display name, so stat-style origin changes (size) don't fire onNameChange. */
+    protected _lastOriginName: string | null;
+    protected _initializing: boolean;
+    protected _emitter: ListenerEmitter<IWorkbook, IWorkbook.IListeners>;
+    protected _scripts: IScript;
+    protected _theme: ITheme;
+    protected _strings: IStringCollection;
+    protected _ownStrings: boolean;
+    protected _externalBooks: IExternalBookCollection;
+    protected _styles: IStyleCollection;
+    protected _ownStyles: boolean;
+    protected _resources: IResourceCollection;
+    protected _ownResources: boolean;
+    protected _names: INamedCollection;
+    protected _ownNames: boolean;
+    /**
+     * Presents every sheet's tables to {@link _names} as named items.
+     *
+     * @remarks
+     * A single stable instance: `getSources` returns it on every call, and the collection compares
+     * source identity to decide whether to re-subscribe. Building one per call would churn listeners
+     * on every query.
+     */
+    protected _namedTableSource: NamedTableSource;
+    protected _calculation: ICalculation;
+    protected _ownCalculation: boolean;
+    protected _view: IWorkbookView;
+    protected _activeSheetOffset: number;
+    protected _sheets: ISheetCollection;
+    protected _sheetOnNameChange: Map<number, () => void>;
+    protected _sheetOnVisibilityChange: Map<number, () => void>;
+    protected _sheetOnIndexChange: Map<number, () => void>;
+    protected _protection: WorkbookProtection;
+    protected _listenerProtection: IListener.Remove;
+    protected _listenerWorkbookView: IListener.Remove;
+    /** Removes the UI-language subscription that re-renders the unpinned regional format. */
+    protected _listenerLanguage: IListener.Remove;
+    protected _runtime: IRuntime;
+    protected _isDate1904: boolean;
+    /** `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} */
+    getId(): string;
+    /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
+    getVersionId(): number;
+    /** {@inheritDoc IWorkbook.getName} */
+    getName(): string | null;
+    /** {@inheritDoc IWorkbook.getOrigin} */
+    getOrigin(): IWorkbookIO.Origin;
+    /** {@inheritDoc IWorkbook.getView} */
+    getView(): IWorkbookView;
+    /** {@inheritDoc IWorkbook.setView} */
+    setView(view: IWorkbookView): this;
+    /** {@inheritDoc IWorkbook.getRuntime} */
+    getRuntime(): IRuntime;
+    /** {@inheritDoc IWorkbook.setDate1904} */
+    setDate1904(date1904: boolean): this;
+    /** {@inheritDoc IWorkbook.getLocale} */
+    getLocale(): string;
+    /** {@inheritDoc IWorkbook.getPinnedLocale} */
+    getPinnedLocale(): string | null;
+    /** {@inheritDoc IWorkbook.setLocale} */
+    setLocale(locale: string | null): this;
+    /** {@inheritDoc IWorkbook.getLocaleOverrides} */
+    getLocaleOverrides(): LocaleProfileOverrides | null;
+    /** {@inheritDoc IWorkbook.setLocaleOverrides} */
+    setLocaleOverrides(overrides: LocaleProfileOverrides | null): this;
+    /** {@inheritDoc IWorkbook.getStyles} */
+    getStyles(): IStyleCollection;
+    /** {@inheritDoc IWorkbook.getResources} */
+    getResources(): IResourceCollection;
+    /** {@inheritDoc IWorkbook.getTransactions} */
+    getTransactions(): ITransaction.IStore;
+    /** {@inheritDoc IWorkbook.getStrings} */
+    getStrings(): IStringCollection;
+    /** {@inheritDoc IWorkbook.getExternalBooks} */
+    getExternalBooks(): IExternalBookCollection;
+    /** {@inheritDoc IWorkbook.getTheme} */
+    getTheme(): ITheme;
+    /** {@inheritDoc IWorkbook.setTheme} */
+    setTheme(theme: ITheme): ITheme;
+    /** {@inheritDoc IWorkbook.getSelectedSheetIndex} */
+    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.getSheets} */
+    getSheets(): ISheetCollection;
+    /** {@inheritDoc IWorkbook.addSheet} */
+    addSheet(options?: ISheetCollection.AddOptions | string | number): ISheet;
+    protected _getSheets(visibility?: ISheet.Visibility): ISheet[];
+    protected _getSheetRefs(visibility?: ISheet.Visibility): SheetRef[];
+    /** @internal */
+    protected _getSheetRef(key: SheetKey | null | undefined, visibility?: ISheet.Visibility): SheetRef | null | undefined;
+    /** @internal */
+    protected _validateNewSheetName(sheetName: string | null | undefined, checkDuplicates?: boolean): string | null | undefined;
+    /** {@inheritDoc IWorkbook.findValidSheetName} */
+    findValidSheetName(str: string): string;
+    /** {@inheritDoc IWorkbook.isValidSheetNameCharacter} */
+    isValidSheetNameCharacter(character: string): boolean;
+    /** @internal */
+    protected _addSheetOptions(options?: ISheetCollection.AddOptions | string | number): ISheet;
+    /** @internal */
+    protected _nextSheetName(sheetName?: string | null | undefined): string;
+    /** @internal */
+    protected _addSheet(notify: boolean, sheetName?: string | null, index?: number | null): ISheet;
+    /** @internal */
+    protected _updateSheetRefStates(sheetRefs: SheetRef[]): void;
+    /** @internal */
+    protected _addSheetRef(sheetRefAdd: SheetRef, index?: number | null): SheetRef;
+    /** @internal */
+    protected _adjustRemoveSelectionIfRequired(indexRemove: number, id: number | null | undefined): void;
+    /** @internal */
+    protected _adjustSheetNamesIfRequired(): void;
+    /** @internal */
+    protected _validateDeleteSheet(key: SheetKey): void;
+    /** @internal */
+    protected _getOffsetForId(id: number | null | undefined, refs: SheetRef[]): number;
+    /** {@inheritDoc IWorkbook.find} */
+    find(options: string | ICellRange.FindOptions): Iterator<ICell>;
+    /** {@inheritDoc IWorkbook.replace} */
+    replace(cells: Iterator<ICell>, replace: ICell.Update | ((original: ICell) => ICell.Update), options?: IWorkbook.ReplaceOptions): IWorkbook.ReplaceResults;
+    /** @internal */
+    protected _nextSheetIndex(index: number, refs?: SheetRef[]): number;
+    /** @internal */
+    protected _prevSheetIndex(index: number, refs?: SheetRef[]): number;
+    /** {@inheritDoc IWorkbook.getNextSheet} */
+    getNextSheet(index: number): ISheet;
+    /** {@inheritDoc IWorkbook.getPreviousSheet} */
+    getPreviousSheet(index: number): ISheet;
+    /** @internal */
+    protected _duplicateSheet(key?: SheetKey | null): Promise<ISheet | null>;
+    /** @internal */
+    protected _createRange(coords: IRange.FixableCoords, getOptions?: ICellRange.GetRangeOptions): ICellRange;
+    /** @internal */
+    protected _createRanges(coords: IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc IWorkbook.getRange} */
+    getRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc IWorkbook.getCell} */
+    getCell(address?: ICell.Address): ICell;
+    /** {@inheritDoc IWorkbook.getRanges} */
+    getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
+    /**
+     * A calculation-graph answer: cell coords plus defined-name NODES, one `ICellRanges`.
+     *
+     * @remarks
+     * Backs `Calculation.ConstructorOptions.createGraphRanges` — the seam where the calculation
+     * layer's graph facts become ranges. Each node becomes a {@link NamedCellRange} anchored at the
+     * name's defining cell (DESIGN-NAMED-FORMULAS.md §4.1); a node whose anchor sheet cannot be
+     * 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;
+    /** {@inheritDoc IWorkbook.getStats} */
+    getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
+    /** @internal */
+    protected _activeRangeCoords(): IRange.FixableCoords[];
+    /** {@inheritDoc IWorkbook.getSelectedRange} */
+    getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc IWorkbook.getSelectedRanges} */
+    getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc IWorkbook.getSelectedCell} */
+    getSelectedCell(): ICell;
+    /** @internal */
+    protected _rangesAddressToCoords(address: ICellRanges.Address, performLookup?: boolean, visibility?: ISheet.Visibility): IRange.FixableCoords[];
+    /** @internal */
+    protected _validateCoords(coords: IRange.FixableCoords, visibility?: ISheet.Visibility, oobMessage?: string): void;
+    /** @internal */
+    protected _updateSheetRef(refOriginal: SheetRef, refNew: SheetRef): SheetRef;
+    /**
+     * Fires onSheetsChange
+     * @internal
+     */
+    protected _setSheetName(key: SheetKey | null, sheetName: string | null | undefined, options?: ITransaction.OperationOptions): ISheet;
+    /**
+     * Fires onSheetsChange
+     * @internal
+     */
+    protected _setSheetVisibility(key: SheetKey | null, visibility?: ISheet.Visibility, options?: ITransaction.OperationOptions): ISheet | null | undefined;
+    /** @internal */
+    protected _moveSheet(ref: SheetRef, indexTo: number, options?: ITransaction.OperationOptions): ISheet | null | undefined;
+    /** @internal */
+    protected _setSelectedSheet(key: SheetKey | null): ISheet;
+    /** {@inheritDoc IWorkbook.getProtection} */
+    getProtection(): IWorkbookProtection;
+    /** {@inheritDoc IWorkbook.getNames} */
+    getNames(): INamedCollection;
+    /** {@inheritDoc IWorkbook.getCalculation} */
+    getCalculation(): ICalculation;
+    /** {@inheritDoc IWorkbook.createFormula} */
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula;
+    /** {@inheritDoc IWorkbook.evaluate} */
+    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords>): Promise<Scalar | IRange>;
+    /** {@inheritDoc IWorkbook.whenCalculationReady} */
+    whenCalculationReady(): Promise<ICalculation.Status>;
+    /** {@inheritDoc IWorkbook.getScripts} */
+    getScripts(): IScript;
+    /** @internal */
+    protected _notifyAllChange(): void;
+    /** {@inheritDoc IWorkbook.addListeners} */
+    addListeners(listeners: IWorkbook.IListeners, options?: IListener.Options): IListener.Remove;
+    /** @internal */
+    protected _sheetToWBEvent(listenerWB: ICellRange.Listener): ICellRange.Listener;
+    /** @internal */
+    protected _fromJSON(json: IWorkbook.JSON): void;
+    /** @internal */
+    protected _createScripts(json?: Record<string, IModule.JSON>): IScript;
+    /** {@inheritDoc IWorkbook.toJSON} */
+    toJSON(options?: ISheet.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>;
+    /** @internal */
+    protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+    /** @internal */
+    protected _getState(): State;
+    /** @internal */
+    protected _updateState(updateState?: Readonly<Partial<State>> | ((prev: Readonly<State>) => Readonly<State>), description?: string, options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc IWorkbook.options} */
+    get options(): IWorkbook.ConstructorOptions;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IWorkbook.isIWorkbook} */
+    get isIWorkbook(): true;
+}
+/**
+ * The reference to a sheet with in a workbook.
+ * These are used for finding sheet and determining
+ * it's location/visibility within a workbook.
+ */
+interface SheetRef {
+    /**
+     * This is a unique id for the sheet.
+     * Note - It is not the index and will not change if the sheet order is adjusted
+     */
+    id: number;
+    /**
+     * The display name of the sheet
+     */
+    name: string;
+    /**
+     * @defaultValue ISheet.Visibility.Visible
+     */
+    visibility: ISheet.Visibility;
+    /**
+     * The sheet model
+     */
+    sheet: ISheet;
+}
+type SheetKey = ISheet | SheetRef | string | {
+    id: number;
+} | number;
+interface State {
+    sheetRefsAll: SheetRef[];
+    sheetRefsVisibleAndHidden: SheetRef[];
+    sheetRefsVisible: SheetRef[];
+    refsById: Map<number, SheetRef>;
+    sheetsById: Map<number, ISheet>;
+    refsByLowerCaseName: Map<string, SheetRef>;
+    sheetsByLowerCaseName: Map<string, ISheet>;
+    refsByInstance: Map<ISheet, SheetRef>;
+    lastId: number;
+    sheetsCreated: Set<ISheet>;
+    listenersSheets: Map<number, IListener.Remove>;
+}
+interface InternalCreateSheet {
+    (
+    /**
+     * The id of the sheet being created.
+     */
+    id: number, 
+    /**
+     * The name of the new  sheet.
+     */
+    name: string, 
+    /**
+     * @defaultValue - ISheet.Visibility.Visible
+     */
+    visibility: ISheet.Visibility, 
+    /**
+     * The location of the sheet.
+     * @defaultValue - End of sheets
+     */
+    index: number | null, 
+    /**
+     * The JSON representation of the sheet.
+     */
+    json: ISheet.JSON | null | undefined): ISheet;
+}
+export {};
+//# sourceMappingURL=Workbook.d.ts.map

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

@@ -0,0 +1,25 @@
+import { IRange } from '@sheetxl/primitives';
+import { IListener } from '../listener';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IWorkbook } from './IWorkbook';
+import { SheetRange, SheetRangeOptions } from '../sheet/SheetRange';
+import { ISheetInternal } from '../sheet/Sheet';
+export interface WorkbookRangeOptions extends SheetRangeOptions {
+}
+/**
+ * Extends I SheetRanges to have a sheet scope and to allow individual ranges to be on different sheets.
+ */
+export declare class WorkbookRange extends SheetRange implements ICellRange {
+    protected _workbook: IWorkbook;
+    constructor(coords: IRange.FixableCoords, internal: ISheetInternal, 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} */
+    addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc ICellRange.getAddress} */
+    getAddress(r1c1?: boolean): string;
+    /** {@inheritDoc ICellRange.toString} */
+    toString(): string;
+}
+//# sourceMappingURL=WorkbookRange.d.ts.map

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

@@ -0,0 +1,39 @@
+import { IRange } from '@sheetxl/primitives';
+import { IListener } from '../listener';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IWorkbook } from './IWorkbook';
+import { SheetRanges, SheetRangesOptions } from '../sheet/SheetRanges';
+import { ISheetInternal } from '../sheet/Sheet';
+export interface WorkbookRangesOptions extends SheetRangesOptions {
+}
+/**
+ * Extends ICellRanges to have a sheet scope and to allow individual ranges to be on different sheets.
+ */
+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);
+    /** {@inheritDoc ICellRange.getSource} */
+    getSource<S>(): S;
+    protected _createRanges(coords: readonly IRange.Coords[], getOptions?: ICellRange.GetRangeOptions): this;
+    protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc ICellRanges.select} */
+    select(options?: ICellRange.SelectOptions): Promise<this>;
+    /** {@inheritDoc ICellRanges.addListener} */
+    addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    get [Symbol.toStringTag](): string;
+    /**
+     * {@inheritDoc ICellRanges.getAddress}
+     *
+     * @remarks
+     * ALWAYS sheet-qualified (`Sheet1!A1:B2`) — that is what makes these ranges workbook-scoped rather
+     * than sheet-scoped, and each range carries its own `scope` so a multi-sheet set round-trips. A
+     * range that carries none takes the bound sheet's name as its default (the same
+     * `scope`-as-`defaultRange` contract the singular {@link WorkbookRange.getAddress} uses).
+     * Contrast {@link SheetRanges.getAddress}, which is deliberately BARE: a sheet-scoped set has one
+     * implicit sheet and nothing to qualify against.
+     */
+    getAddress(r1c1?: boolean): string;
+    /** {@inheritDoc ICellRanges.toString} */
+    toString(): string;
+}
+//# sourceMappingURL=WorkbookRanges.d.ts.map

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

@@ -0,0 +1,8 @@
+export declare function ERROR_INVALID_ID(id: number): string;
+export declare function ERROR_INVALID_SHEET_KEY(key: any): string;
+export declare function ERROR_NAME_DUPLICATE(sheetName: string): string;
+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;
+//# sourceMappingURL=_WorkbookMessages.d.ts.map

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

@@ -0,0 +1,35 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICellRange } from '../cellRange';
+export declare const RegExInvalidSheetChars: RegExp;
+export declare const RegExAutoSheetName: RegExp;
+export declare function defaultCreateSheetName(index: number): string;
+export declare function createInvalidWorkbookRefRange(address: Partial<IRange.FixableCoords> | null, defaultCoords?: IRange.FixableCoords | null): ICellRange;
+/**
+ * Validates sheet name.
+ *
+ * The character count **MUST** be greater than or equal to 1 and less than or equal to 31.
+ * The string MUST NOT contain the any of the following characters:
+ *
+ * * 0x0000
+ * * 0x0003
+ * * colon (:)
+ * * backslash (\)
+ * * asterisk (*)
+ * * question mark (?)
+ * * forward slash (/)
+ * * opening square bracket ([)
+ * * closing square bracket (])
+ *
+ * The string MUST NOT begin or end with the single quote (') character.
+ *
+ * @param sheetName the name to validate
+ * @throws IllegalArgumentException if validation fails
+ * @internal
+ */
+export declare function _validateNewSheetName(sheetName: string, force?: boolean): string;
+/**
+ * Find a valid sheet name.
+ * @internal
+ */
+export declare function findValidSheetName(str: string, validate: (validating: string) => string): string;
+//# sourceMappingURL=_WorkbookUtils.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+import { IProtection } from '../protection/IProtection';
+/**
+ * Interface representing protection settings for a workbook.
+ * This interface allows for getting and setting passwords,
+ * managing structure and window locks, and handling revision protection.
+ */
+export interface IWorkbookProtection extends IProtection<IWorkbookProtection, IWorkbookProtection.Properties, IWorkbookProtection.JSON> {
+    /**
+     * Checks if the workbook structure is locked.
+     * Locking the structure prevents changes like adding or deleting sheets.
+     *
+     * @returns `true` if the structure is locked, `false` otherwise.
+     */
+    isStructureAllowed(): boolean;
+    /**
+     * Checks if workbook windows are locked.
+     * Locking the windows prevents changes to window position and size.
+     *
+     * @returns `true` if windows are locked, `false` otherwise.
+     */
+    isWindowsAllowed(): boolean;
+    /**
+     * Checks if workbook revisions are locked.
+     * Locking revisions prevents changes to the workbook without the revision password.
+     *
+     * @returns `true` if revisions are locked, `false` otherwise.
+     */
+    isRevisionAllowed(): boolean;
+}
+/**
+ * {@inheritDoc IWorkbookProtection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IWorkbookProtection}
+ */
+export declare namespace IWorkbookProtection {
+    interface IListener {
+        /**
+         * Called when the protection has changed collections has changed have changed.
+         */
+        onChange?(source: IWorkbookProtection): void;
+    }
+    interface Properties extends IProtection.JSON {
+        revisionsPassword?: Partial<IProtection.EncryptedPassword>;
+        structure?: boolean;
+        windows?: boolean;
+        revision?: boolean;
+    }
+    interface JSON extends IProtection.JSON {
+        revisionsPassword?: Partial<IProtection.EncryptedPassword>;
+        structure?: boolean;
+        windows?: boolean;
+        revision?: boolean;
+    }
+}
+//# sourceMappingURL=IWorkbookProtection.d.ts.map

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

@@ -0,0 +1,14 @@
+import { DefaultProtection } from '../protection/DefaultProtection';
+import { IWorkbookProtection } from './IWorkbookProtection';
+export declare class WorkbookProtection extends DefaultProtection<IWorkbookProtection, IWorkbookProtection.Properties, IWorkbookProtection.JSON> implements IWorkbookProtection {
+    /** {@inheritDoc IProtection.isWindowsAllowed} */
+    isWindowsAllowed(): boolean;
+    /** {@inheritDoc IProtection.isRevisionAllowed} */
+    isRevisionAllowed(): boolean;
+    /** {@inheritDoc IWorkbookProtection.isStructureAllowed} */
+    isStructureAllowed(): boolean;
+    protected _fromJSON(json: IWorkbookProtection.JSON | null): void;
+    protected _toJSON(json: IWorkbookProtection.JSON): IWorkbookProtection.JSON;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=WorkbookProtection.d.ts.map

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

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

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

@@ -0,0 +1,134 @@
+import { IListener } from '../listener';
+/**
+ * View settings for a single workbook.
+ *
+ */
+export interface IWorkbookView {
+    /**
+     * Shows the visibility of the formula bar.
+     */
+    setShowFormulaBar(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setShowFormulaBar}
+     */
+    isShowFormulaBar(): boolean;
+    /**
+     * Shows the workbook tabs.
+     *
+     * @defaultValue true;
+    */
+    setShowTabs(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setShowTabs}
+     */
+    isShowTabs(): boolean;
+    /**
+     * Specifies ratio between the workbook tabs and the horizontal scroll bar.
+     *
+     * @defaultValue 600
+     *
+     * @remarks
+     * This is expressed as a percent * 1000.
+     */
+    setTabRatio(newValue: number): this;
+    /**
+     * @see {@link IWorkbookView.setTabRatio}
+     */
+    getTabRatio(): number;
+    /**
+     * show the horizontal scrollbar.
+     *
+     * @defaultValue true
+     */
+    setShowHorizontalScrollbar(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setShowHorizontalScrollbar}
+     */
+    isShowHorizontalScrollbar(): boolean;
+    /**
+     * Show the vertical scrollbar.
+     *
+     * @defaultValue true
+     */
+    setShowVerticalScrollbar(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setShowVerticalScrollbar}
+     */
+    isShowVerticalScrollbar(): boolean;
+    /**
+     * Show the status bar.
+     * @defaultValue true
+     */
+    setShowStatusBar(newValue: boolean): this;
+    /**
+     * @see {@link IWorkbookView.setShowStatusBar}
+     */
+    isShowStatusBar(): boolean;
+    /**
+     * The id of of the activeSheet.
+     *
+     * @remarks
+     * This is NOT the index of the sheet but instead the id (1 based)
+     * If the sheets have been reordered then these won't match.
+     */
+    setActiveSheetId(newValue: number | null): this;
+    /**
+     * @see {@link IWorkbookView.setActiveSheetId}
+     */
+    getActiveSheetId(): number | null;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IWorkbookView.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Saves the current state to JSON.
+     */
+    toJSON(): IWorkbookView.JSON | null;
+}
+/**
+ * {@inheritDoc IWorkbookView}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IWorkbookView}
+ */
+export declare namespace IWorkbookView {
+    interface Events {
+        /**
+         * Called when the workbookView changes.
+         *
+         * @param source {@link IWorkbookView}
+         */
+        onViewChange?(source: IWorkbookView): void;
+    }
+    interface IListeners extends IListener.Callbacks<IWorkbookView, IWorkbookView.Events> {
+    }
+    interface ConstructorOptions {
+        /**
+         * The state to load
+         */
+        json?: IWorkbookView.JSON;
+    }
+    interface Properties {
+        /** {@inheritDoc IWorkbookView.setShowFormulaBar} */
+        showFormulaBar?: boolean;
+        /** {@inheritDoc IWorkbookView.setShowTabs} */
+        showTabs?: boolean;
+        /** {@inheritDoc IWorkbookView.setTabRatio} */
+        tabRatio?: number;
+        /** {@inheritDoc IWorkbookView.setShowHorizontalScrollbar} */
+        showHorizontalScrollbar?: boolean;
+        /** {@inheritDoc IWorkbookView.setShowVerticalScrollbar} */
+        showVerticalScrollbar?: boolean;
+        /** {@inheritDoc IWorkbookView.setShowStatusBar} */
+        showStatusBar?: boolean;
+        /** {@inheritDoc IWorkbookView.setActiveSheetId} */
+        activeSheetId?: number | null;
+    }
+    interface JSON extends Properties {
+    }
+}
+//# sourceMappingURL=IWorkbookView.d.ts.map