@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

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

@@ -0,0 +1,711 @@
+import { Scalar, IRange, IRangeStats, IRuntime, LocaleProfileOverrides } from '@sheetxl/primitives';
+import { FunctionProvider } from '@sheetxl/scripting';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { IResourceCollection, IResource } from '../resource';
+import { IStringCollection } from '../string';
+import { ICalculation } from '../calculation';
+import { IScript, IModule } from '../scripting';
+import { ICell } from '../cell';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IComment } from '../comment';
+import { INamedCollection } from '../named';
+import { IExternalBook, IExternalBookCollection } from '../externalBook';
+import { ITheme } from '../theme';
+import { IStyleCollection } from '../style';
+import { ISheet, ISheetCollection, ICellContainerOptions } from '../sheet';
+import { IWorkbookView } from '../workbookView';
+import { IWorkbookProtection } from '../workbookProtection';
+import { IWorkbookIO } from '../io';
+/**
+ * An `IWorkbook` represents a collection of {@link ISheet | sheets}, along with shared resources.
+ *
+ * This interface provides methods for accessing its elements and event handling.
+ *
+ * @remarks
+ * Most interactions with a {@link IWorkbook | workbook} or {@link ISheet | sheet} are done through a
+ * {@link ICellRange | workbook range}.
+ *
+ * @see
+ * * {@link getRange} - For interacting with cell values and formatting on a single {@link ISheet | sheet}.
+ * * {@link getSheets} - For managing {@link ISheet | sheet}.
+ * * {@link getNames} - For managing items with defined names.
+ */
+export interface IWorkbook extends ITransaction.ITransactional, IListener.ISource<IWorkbook, IWorkbook.IListeners> {
+    /**
+     * Returns the collection of sheets within the workbook.
+     */
+    getSheets(): ISheetCollection;
+    /**
+     * Adds a new sheet to the workbook.
+     *
+     * @remarks
+     * This is a convenience method that wraps `{@link ISheetCollection.add}`.
+     */
+    addSheet(options?: ISheetCollection.AddOptions | string | number): ISheet;
+    /**
+     * Returns the sheet at the given offset.
+     *
+     * @param index A 0-based index of the sheet.
+     * @param visibility The visibility of the sheet.
+     */
+    getSheetAt(index: number, visibility?: ISheet.Visibility): ISheet;
+    /**
+     * Returns the sheet for the given name, or the selected sheet when no name is given.
+     *
+     * @param name The name of the sheet. Omit for the selected sheet — "the sheet", unqualified,
+     * is the one the user (or agent) is looking at. `getSelectedSheet` remains the explicit form.
+     * @param visibility The visibility of the sheet.
+     */
+    getSheet(name?: string, visibility?: ISheet.Visibility): ISheet;
+    /**
+     * Returns the currently active sheet within the workbook.
+     */
+    getSelectedSheet(): ISheet;
+    /**
+     * Returns the currently active sheet index within the workbook.
+     */
+    getSelectedSheetIndex(): number;
+    /**
+     * Returns ranges scoped to a sheet.
+     *
+     * @param address Address of the ranges. Omit for the selected range — selection is modeled
+     * by the SDK (not a UI mode), and many operations default to it. `getSelectedRange` remains
+     * the explicit form.
+     *
+     * @remarks
+     * When accessing ranges from the `IWorkbook` ranges include a sheet name.
+     * This enables cross-sheet references when working at the workbook level.
+     *
+     * Some examples of cross-sheet reference are:
+     *
+     * - Linking data and formulas across multiple sheets.
+     *
+     * - Consolidating data from different sheets for analysis or reporting.
+     *
+     * - Performing calculations or comparisons that involve values from multiple sheets.
+     */
+    getRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
+    /**
+     * Returns a {@link ICell} at the specified address.
+     *
+     * @param address Address of the cell, optionally sheet-qualified (e.g. `'Sales!B11'`).
+     * Omit for the selected cell — selection is modeled by the SDK (not a UI mode), and many
+     * operations default to it. `getSelectedCell` remains the explicit form.
+     *
+     * @remarks
+     * An address that resolves to more than a single cell is an error.
+     */
+    getCell(address?: ICell.Address): ICell;
+    /**
+     * Returns an a set of ranges including sheet names.
+     *
+     * @param address Address of the ranges.
+     *
+     * @remarks
+     * @see {@link IWorkbook.getRange}
+     */
+    getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
+    /**
+     * Returns the statistics for the used cells across all sheets.
+     *
+     * @param options Iterator options the stats are created with. At workbook scale prefer
+     * `{ onError: 'ignore' }` — some error value existing *somewhere* is likely, and the
+     * default `'throw'` policy treats one as a fault when aggregating.
+     *
+     * @remarks
+     * The workbook form of {@link ISheet.getStats}: every sheet's used range contributes,
+     * including hidden and very-hidden sheets — visibility is a display concern, not a data
+     * one. A workbook with no used cells returns empty statistics (`getSize() === 0`),
+     * never `null`.
+     *
+     * Cross-sheet value ordering (where observable) follows sheet index order.
+     *
+     * @see
+     * {@link ICellRange.getStats}
+     */
+    getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
+    /**
+     * Returns a range of cells for the current selection.
+     */
+    getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /**
+     * Returns ranges of cells for the current selection.
+     */
+    getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /**
+     * Returns the selected cell.
+     */
+    getSelectedCell(): ICell;
+    /**
+     * Search the entire Workbook.
+     *
+     * @param options The text to search for or {@link ICellRange.FindOptions}
+     *
+     * @remarks
+     * Searches all sheets.
+     *
+     * @see
+     * {@link ICellRange.find}
+     */
+    find(options: string | ICellRange.FindOptions): Iterator<ICell>;
+    /**
+     * Replace all items in the iterator
+     *
+     * @param cells An iterator of cells to replace.
+     * @param replace The {@link ICell.Update} or a callback to replace with.
+     */
+    replace(cells: Iterator<ICell>, replace: ICell.Update | ((original: ICell) => ICell.Update), options?: IWorkbook.ReplaceOptions): IWorkbook.ReplaceResults;
+    /**
+     * Returns the next sheet in the sheets collection. If the last one it will return the first.
+     *
+     * @remarks
+     * If there is only 1 sheet this will return the current sheet.
+     */
+    getNextSheet(index: number): ISheet;
+    /**
+     * Returns the previous sheet in the sheets collection. If the first one it will return the last.
+     *
+     * @remarks
+     * If there is only 1 sheet this will return the current sheet.
+     */
+    getPreviousSheet(index: number): ISheet;
+    /**
+     * Given the name return a valid name that closely matches.
+     *
+     * @param sheetName The string to validate.
+     */
+    findValidSheetName(sheetName: string): string;
+    /**
+     * Indicate if the current character is a valid character for a sheetName.
+     *
+     * @param character The string to validate.
+     */
+    isValidSheetNameCharacter(character: string): boolean;
+    /**
+     * Returns the current view settings.
+     *
+     * View settings determine how specific workbook level elements are displayed but does not affect the underlying data itself.
+     */
+    getView(): IWorkbookView;
+    /**
+     * Views have their own lifecycle because in a collaborative environment each user can have their own view.
+     */
+    setView(view: IWorkbookView): this;
+    /**
+     * Returns the current `IStyleCollection` associated with this Workbook.
+     */
+    getStyles(): IStyleCollection;
+    /**
+     * Returns the current shared resources.
+     */
+    getResources(): IResourceCollection;
+    /**
+     * Returns the current shared resources.
+     */
+    getStrings(): IStringCollection;
+    /**
+     * Returns the current shared resources.
+     */
+    getTransactions(): ITransaction.IStore;
+    /**
+     * Get the current theme.
+     */
+    getTheme(): ITheme;
+    /**
+     * Set the current theme.
+     *
+     * @remarks
+     * * If `null` sets back to the default theme.
+     * * Does not fire a theme updated event.
+     */
+    setTheme(theme: ITheme | null): ITheme;
+    /**
+     * A stable name for the workbook.
+     */
+    getId(): string;
+    /**
+     * Returns the display name for the workbook — a pure, read-only derivation of its
+     * {@link getOrigin | origin}'s name — or `null` for an unbound, unnamed workbook.
+     *
+     * @remarks
+     * A workbook has no intrinsic name (like Excel: a workbook's name *is* its file name). Display
+     * fallbacks (a localized "Untitled") are a UI concern. Renaming is an origin/document-level
+     * operation (see `WorkbookDocument.setName`), never a model edit — it is not undoable.
+     */
+    getName(): string | null;
+    /**
+     * Returns the workbook's {@link IWorkbookIO.Origin | origin} — the virtual file handle it maps to.
+     *
+     * @remarks
+     * Read-only and always present: the *reference* is stable for the workbook's lifetime (a new
+     * in-memory workbook holds an *unbound* origin — `getPath()` `null`). The origin **object** is
+     * updated in place by its IO/store owner (e.g. a first save resolving a destination), like the
+     * DOM's `document.URL` — the model itself never mutates it, and it is not part of the persisted
+     * document ({@link toJSON}); a copy mints a fresh unbound origin.
+     */
+    getOrigin(): IWorkbookIO.Origin;
+    /**
+     * Returns the runtime used for this workbook.
+     *
+     * @see {@link @sheetxl/primitives!IRuntime}
+     */
+    getRuntime(): IRuntime;
+    /**
+     * Determine if dates should be 1904 instead of 1900 based.
+     *
+     * @param date1940 - default value `false`
+     *
+     * @see
+     * {@link IWorkbook.isDate1904}
+     */
+    setDate1904(date1940: boolean): this;
+    /**
+     * Returns the regional locale of the workbook as a BCP 47 tag, e.g. `de-DE`.
+     *
+     * @remarks
+     * Determines number/date formatting and parsing, separators, and collation.
+     * Falls back to the environment locale when the workbook does not pin one.
+     *
+     * @see
+     * {@link IWorkbook.setLocale}
+     */
+    getLocale(): string;
+    /**
+     * Returns the locale explicitly pinned on the workbook, or `null` when it
+     * follows the environment locale.
+     *
+     * @remarks
+     * {@link IWorkbook.getLocale} always resolves to a concrete tag; this is the
+     * only way to tell a pinned locale from an environment fallback that happens
+     * to match it. Only a pinned locale is persisted.
+     *
+     * @see
+     * {@link IWorkbook.setLocale}
+     */
+    getPinnedLocale(): string | null;
+    /**
+     * Set the regional locale of the workbook.
+     *
+     * @param locale - A BCP 47 tag, e.g. `de-DE`. Pass `null` to follow the
+     * environment locale.
+     *
+     * @remarks
+     * This is a display/input concern only. Stored formulas, error values, and
+     * number formats remain canonical, so the workbook still opens correctly
+     * under any other locale.
+     *
+     * @see
+     * {@link IWorkbook.getLocale}
+     */
+    setLocale(locale: string | null): this;
+    /**
+     * Returns the workbook's locale-profile overrides (the regional-override patch), or
+     * `null` when the profile is entirely `Intl`-derived from {@link IWorkbook.getLocale}.
+     *
+     * @see
+     * {@link IWorkbook.setLocaleOverrides}
+     */
+    getLocaleOverrides(): LocaleProfileOverrides | null;
+    /**
+     * Patch individual derived regional settings on top of the locale — the escape
+     * hatch for the OS-level customizations (a custom decimal symbol, a different
+     * currency) that browser `Intl` cannot see.
+     *
+     * @param overrides - A literal patch over the derived `LocaleProfile` (e.g.
+     * `{ decimal: '.', currencySymbol: 'CHF' }`), or `null` to clear. Applied
+     * literally — nothing is re-derived, so patch `listSeparator` too if you patch
+     * `decimal`. Persisted in `.sxl` alongside the locale tag (never in `.xlsx`).
+     *
+     * @see
+     * {@link IWorkbook.getLocaleOverrides}
+     */
+    setLocaleOverrides(overrides: LocaleProfileOverrides | null): this;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IWorkbook.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Returns the protection object for the workbook.
+     */
+    getProtection(): IWorkbookProtection;
+    /**
+     * **Every** {@link INamed} in the workbook — global names, every sheet's scoped names, and every
+     * table — sorted by type then by name.
+     *
+     * @remarks
+     * The name-manager view: what EXISTS, not what any one sheet can see. A global name and a
+     * sheet-scoped name that share a name are two items here and both are returned; ask
+     * {@link ISheet.getNames} for the one a formula on that sheet would resolve to.
+     */
+    getNames(): INamedCollection;
+    /**
+     * The workbook's external books — cached snapshots of other workbooks, addressed from a formula
+     * as `[n]Sheet1!$A$1`. In `[n]` order.
+     *
+     * @remarks
+     * Read-only for now: this phase reads and models the parts, nothing more. Formula text still
+     * carries `[n]` as opaque characters — this collection is not yet wired to it.
+     */
+    getExternalBooks(): IExternalBookCollection;
+    /**
+     * Returns the {@link ICalculation} for the workbook.
+     */
+    getCalculation(): ICalculation;
+    /**
+     * Parses a formula expression and returns a *transient* formula object.
+     *
+     * @param expression The formula expression to parse.
+     * @param coords Optional anchor coordinates.
+     *
+     * @remarks
+     * This is a convenience method for `getCalculation().createFormula(expression, coords)`.
+     * A bare reference (`A2`) resolves against the active cell's sheet; use
+     * {@link ISheet.createFormula} to anchor against a specific sheet.
+     *
+     * @see {@link ICalculation.createFormula}
+     */
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula;
+    /**
+     * Evaluates a formula in the context of the sheet and returns the resulting value.
+     *
+     * @param formula The formula to evaluate.
+     * @param options Optional evaluation options.
+     *
+     * @remarks
+     * This is similar convenience method for `getCalculation().createFormula(expression).evaluate(options)`.
+     */
+    evaluate(formula: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords>): Promise<Scalar | IRange>;
+    /**
+     * Returns when all calculations are complete and there are no pending calculations.
+     *
+     * @remarks
+     * * This is a convenience method `getCalculation().ready()`.
+     */
+    whenCalculationReady(): Promise<ICalculation.Status>;
+    /**
+     * Returns any user defined functions stored with the workbook.
+     */
+    getScripts(): IScript;
+    /**
+     * Serialize the workbook to a JSON.
+     *
+     * @param options Options to control the JSON output.
+     */
+    toJSON(options?: ISheet.ToJSONOptions): Promise<IWorkbook.JSON>;
+    /**
+     * Returns any custom workbook options that are provided in constructor.
+     */
+    readonly options: IWorkbook.ConstructorOptions;
+    /**
+     * Close the workbook and release any resources.
+     *
+     * @remarks
+     * No further operations are allowed after a close.
+     */
+    close(): void;
+    /**
+     * Indicates if the model has been closed.
+     */
+    isClosed(): boolean;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIWorkbook: true;
+}
+/**
+ * {@inheritDoc IWorkbook}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IWorkbook}
+ */
+export declare namespace IWorkbook {
+    /**
+     * Represents the different ways to identify ranges within a workbook, including the sheet context.
+     *
+     * Accepts:
+     * - `ICellRange`
+     * - A parsable `string` representing a range address, optionally including the sheet name (e.g., "Sheet1!A1:B2").
+     * - A partial `IRange.FixableCoords` object (specifying at least some of the range boundaries),
+     *   which may include the `sheetName` property to identify the sheet.
+     * - `IWorkbook.CellAddress` (representing a single cell within the workbook),
+     *   which may includes the `sheetName` property to identify the sheet.
+     *
+     * @example
+     * ```typescript
+     * const address1: Address = "Sheet1!A1:B2"; // A1 notation with sheet name
+     * ```
+     *
+     * @remarks
+     * This leverages {@link ICellRange.Address} and adds the sheet name.
+     */
+    type RangeAddress = ICellRange | string | Partial<IRange.FixableCoords> | IWorkbook.CellAddress;
+    /**
+     * Represents the different ways to identify multiple ranges within a workbook,
+     * including their sheet context.
+     *
+     * Accepts:
+     * - `ICellRanges`
+     * - A parsable `string` containing multiple range addresses, optionally including sheet names,
+     *    separated by commas (e.g., "Sheet1!A1:B2,Sheet2!C3:D4").
+     * - An array of `IWorkbook.RangeAddress` objects, each representing a single range within a workbook.
+     *
+     * @example
+     * ```typescript
+     * const address1: IWorkbook.RangesAddress = "Sheet1!A1:B2,Sheet2!C3:D4"; // String with multiple ranges and sheet names
+     * ```
+     *
+     * @remarks
+     * This extends {@link ICellRanges.Address} to support multiple values.
+     */
+    type RangesAddress = ICellRanges | string | IWorkbook.RangeAddress | readonly IWorkbook.RangeAddress[];
+    /**
+     * Represents a single cell a workbook.
+     */
+    type CellAddress = IRange.FixableCellCoords | string;
+    /**
+     * IListener interface for {@link IWorkbook} events.
+     */
+    interface Events {
+        /**
+         * Called when the sheet collections has changed have changed.
+         */
+        onSheetsChange?(source: IWorkbook): void;
+        /**
+         * Called when the workbook theme has changed.
+         */
+        onThemeChange?(source: IWorkbook): void;
+        /**
+         * Called when the workbook protection has changed.
+         *
+         * @remarks
+         * This is different from the sheet protection.
+         */
+        onProtectionChange?(source: IWorkbook): void;
+        /**
+         * Called before load. If any exception is thrown this
+         * exception will be returned to the client and delete will fail.
+         */
+        onBeforeLoad?(source: IWorkbook, json: IWorkbook.JSON): void;
+        /**
+         * Called after load.
+         */
+        onLoad?(source: IWorkbook): void;
+        /**
+         * Called before load. If any exception is thrown this
+         * exception will be returned to the client and delete will be aborted.
+         */
+        onBeforeSave?(source: IWorkbook): Promise<void> | void;
+        /**
+         * Called after save.
+         */
+        onSave?(source: IWorkbook, json: IWorkbook.JSON): void;
+        /**
+         * Called when the workbookView changes.
+         *
+         * @param source {@link IWorkbook}
+         */
+        onViewChange?(source: IWorkbook): void;
+        /**
+         * Called when the display name changes — a convenience proxy of the origin's `onChange`
+         * (non-transactional; renames are not model edits and never enter the undo stack).
+         */
+        onNameChange?(source: IWorkbook): void;
+        /**
+         * Called when the scripts associated with the workbook have change.
+         */
+        onScriptsChange?(source: IWorkbook): void;
+        /**
+         * Request that the sheet become brought to the front.
+         *
+         * @returns A promise indicating that the sheet has been rendered.
+         *
+         * @remarks
+         * This should only be handled by one consumer.
+         */
+        onRequestSelect?(source: IWorkbook, sheet: ISheet): Promise<boolean>;
+        /**
+         * Called when the cell selection has changed.
+         *
+         * @param source The workbook instance.
+         */
+        onSelectionChange?(source: IWorkbook): void;
+        /**
+         * Called when the selected sheet has changed.
+         *
+         * @param source The workbook instance.
+         */
+        onSelectedSheetChange?(source: IWorkbook): void;
+        /**
+         * Called when the sheets have change.
+         *
+         * @param source The workbook instance.
+         */
+        onSheetsChange?(source: IWorkbook): void;
+        /**
+         * Called when the workbook is closed.
+         */
+        onClose?(source: IWorkbook): void;
+        /**
+         * Called when the state has been updated due to a undo/redo and a rerender is required.
+         */
+        onInvalidated?(source: IWorkbook): void;
+    }
+    interface IListeners extends IListener.Callbacks<IWorkbook, IWorkbook.Events> {
+    }
+    /**
+     * Options for the replace operation.
+     */
+    interface ReplaceOptions extends ITransaction.OperationOptions {
+        /**
+         * The maximum number of cells to replace.
+         * @defaultValue false
+         */
+        maxCount?: number;
+        /**
+         * The axis to replace.
+         */
+        axis?: IRange.Axis;
+    }
+    interface ReplaceResults {
+        /**
+         * The number of cell replaced.
+         */
+        count: number;
+        /**
+         * The last cell replaced, or `null` when nothing was replaced.
+         */
+        last: ICell | null;
+    }
+    /**
+     * Used for persisting metadata about a `ISheet`.
+     */
+    interface SheetRefJSON {
+        /**
+         * A unique name for the sheet.
+         */
+        name: string;
+        /**
+         * @defaultValue ISheet.Visibility.Visible
+         */
+        visibility?: ISheet.Visibility;
+        /**
+         * The actual sheet.
+         */
+        sheet?: ISheet.JSON;
+    }
+    /**
+     * JSON representation of an `IWorkbook` used for serialization and deserialization.
+     */
+    interface JSON {
+        sheets: SheetRefJSON[];
+        styles?: IStyleCollection.JSON;
+        resources?: IResource.JSON[];
+        strings?: string[];
+        people?: IComment.PersonJSON[];
+        view?: IWorkbookView.JSON;
+        theme?: ITheme.JSON;
+        names?: INamedCollection.JSON;
+        /**
+         * In `[n]` order (1-based) — index 0 of this array is `[1]`. An entry is `null` where the
+         * source's external link is a DDE/OLE link, or anything else this phase does not model — the
+         * position still counts, only the content does not.
+         */
+        externalBooks?: (IExternalBook.JSON | null)[];
+        scripts?: Record<string, IModule.JSON>;
+        calc?: ICalculation.JSON;
+        protection?: IWorkbookProtection.JSON;
+        date1904?: boolean;
+        /**
+         * The regional locale as a BCP 47 tag, e.g. `de-DE`.
+         *
+         * @remarks
+         * Omitted when the workbook uses the environment locale. Persisted so that
+         * a document renders and parses identically everywhere; there is no
+         * equivalent slot in `xlsx` so this is `sxl` only.
+         */
+        locale?: string;
+        /**
+         * The regional-override patch over the derived locale profile. Omitted
+         * when there is no customization. Like {@link locale}, `sxl` only — `xlsx` has
+         * no slot for it.
+         */
+        localeOverrides?: LocaleProfileOverrides;
+    }
+    /**
+     * Callback to allow for custom `ISheets`. The Workbook provides a default implementation.
+     */
+    interface CreateSheetCallback {
+        (
+        /**
+         * Options used for creating the Sheet instance.
+         */
+        options: ISheet.ConstructorOptions, 
+        /**
+         * The name of the new  sheet.
+         */
+        name: string, 
+        /**
+         * The location of the sheet.
+         */
+        index: number, 
+        /**
+         * @defaultValue ISheet.Visibility.Visible
+         */
+        visibility: ISheet.Visibility): ISheet;
+    }
+    /**
+     * Options available when creating an IWorkbook.
+     */
+    interface ConstructorOptions extends ICellContainerOptions {
+        /**
+         * Additional custom formula function providers, bound after the built-ins (so they override
+         * built-ins on name collision). Each provider is the `initialize` binder produced by the
+         * FormulaCompiler (`@sheetxl/scripting`) for a folder of formula sources.
+         *
+         * @see {@link FunctionProvider}
+         */
+        functions?: readonly FunctionProvider[];
+        /**
+         * A structural transform applied once to each formula parsed from `json` — cell formulas
+         * AND defined names. This is the READ half of the format-dialect hook: a format reader
+         * (e.g. xlsx) supplies its legacy unwrap here; it is a LOAD-time pass only and is never
+         * applied to text typed or set after construction.
+         *
+         * @see {@link ICalculation.FormulaTransform}
+         */
+        formulaTransform?: ICalculation.FormulaTransform;
+        /**
+         * Hook to allow for custom sheet creation.
+         */
+        createSheetCallback?: CreateSheetCallback;
+        /**
+         * Returns a human readable sheet name given a 0-based index.
+         *
+         * @defaultValue `Sheet${index+1}`
+         */
+        createSheetNameCallback?: (index: number) => string;
+        /**
+         * The {@link IWorkbookIO.Origin} the workbook maps to — threaded through by the IO layer at
+         * read time. Omit for an in-memory workbook (an unbound origin is minted). A string is
+         * shorthand for an unbound origin with that display name.
+         *
+         * @remarks
+         * The reference is stable for the workbook's lifetime; see {@link IWorkbook.getOrigin}.
+         */
+        origin?: IWorkbookIO.Origin | string | null;
+        /**
+         * A theme for the workbook.
+         */
+        theme?: ITheme;
+        /**
+         * Load from JSON.
+         */
+        json?: IWorkbook.JSON;
+    }
+}
+//# sourceMappingURL=IWorkbook.d.ts.map