@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/io/WorkbookIO.d.ts

@@ -0,0 +1,91 @@
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+import { IWorkbook } from '../workbook';
+import { IWorkbookIO } from './IWorkbookIO';
+/**
+ * Default implementation of the {@link IWorkbookIO} interface.
+ *
+ * @hidden
+ */
+export declare class DefaultWorkbookIO implements IWorkbookIO {
+    private _registry;
+    private _setInstalled;
+    private _backingStore;
+    private _defaultStore;
+    private _emitter;
+    constructor();
+    /** @inheritdoc IWorkbookIO.getBackingStore */
+    getBackingStore(): IWorkbookIO.IBackingStore;
+    /** @inheritdoc IWorkbookIO.setBackingStore */
+    setBackingStore(store: IWorkbookIO.IBackingStore | null): void;
+    /** @inheritdoc IWorkbookIO.canWrite */
+    canWrite(): boolean;
+    /** @inheritdoc IWorkbookIO.canRead */
+    canRead(): boolean;
+    /** @inheritdoc IWorkbookIO.install */
+    install(plugin: IWorkbookIO.Plugin): Promise<void>;
+    /** @inheritdoc IWorkbookIO.addListeners */
+    addListeners(listeners: IWorkbookIO.Listeners, options?: IListener.Options): IListener.Remove;
+    /** @inheritdoc IWorkbookIO.addCommitListener */
+    addCommitListener(listener: ITransaction.ICommitSource.IListeners): IListener.Remove;
+    /** @inheritdoc IWorkbookIO.getReadFormats */
+    getReadFormats(options?: IWorkbookIO.GetFormatsOptions): Promise<IWorkbookIO.FormatType[]>;
+    /** @inheritdoc IWorkbookIO.getWriteFormats */
+    getWriteFormats(options?: IWorkbookIO.GetFormatsOptions): Promise<IWorkbookIO.FormatType[]>;
+    /** @inheritdoc IWorkbookIO.getOrigin */
+    getOrigin(pathOrUrl: string): IWorkbookIO.Origin;
+    /** @inheritdoc IWorkbookIO.read */
+    read<T extends IWorkbookIO.ReadOptions = IWorkbookIO.ReadOptions>(sourceOrOptions?: string | IWorkbookIO.Origin | T): Promise<IWorkbook | null>;
+    /**
+     * Decodes acquired bytes into a workbook: resolves the read format, records provenance, runs
+     * the handler, and reports progress. Used by a {@link IWorkbookIO.IBackingStore} via
+     * {@link IWorkbookIO.ReadRequest.decode}.
+     *
+     * @internal
+     */
+    protected _decodeBuffer<T extends IWorkbookIO.ReadOptions = IWorkbookIO.ReadOptions>(bytes: ArrayBufferLike, info?: IWorkbookIO.ReadInfo, optionsArg?: T, presetOrigin?: IWorkbookIO.Origin | null): Promise<IWorkbook | null>;
+    /**
+     * Unwraps an encryption envelope, resolving a password from `options.password` and — when that is
+     * absent or rejected — `options.onPassword`.
+     *
+     * @returns The plaintext bytes, the input unchanged when nothing is encrypted, or `null` when the
+     *   caller cancelled the prompt.
+     *
+     * @remarks
+     * This is the whole of the read side of encryption, and it lives here rather than in a format
+     * handler on purpose: an envelope carries opaque bytes, so one implementation serves every format
+     * (see `IWorkbookIO.EncryptionType`). Format handlers never see a password.
+     *
+     * @internal
+     */
+    protected _decrypt<T extends IWorkbookIO.ReadOptions = IWorkbookIO.ReadOptions>(bytes: ArrayBufferLike, origin: IWorkbookIO.Origin, options?: T): Promise<{
+        bytes: ArrayBufferLike;
+        password: string | null;
+    } | null>;
+    /** @inheritdoc IWorkbookIO.writeArrayBuffer */
+    writeArrayBuffer<T extends IWorkbookIO.WriteOptions = IWorkbookIO.WriteOptions>(workbook: IWorkbook, options?: T): Promise<ArrayBufferLike>;
+    /** @inheritdoc IWorkbookIO.write */
+    write<T extends IWorkbookIO.WriteOptions = IWorkbookIO.WriteOptions>(workbook: IWorkbook, target?: string | IWorkbookIO.Origin | T, optionsArg?: T): Promise<IWorkbookIO.Origin | null>;
+    /** @inheritdoc IWorkbookIO.writeAs */
+    writeAs<T extends IWorkbookIO.WriteAsOptions = IWorkbookIO.WriteAsOptions>(workbook: IWorkbook, target: string | IWorkbookIO.Origin, options?: T): Promise<IWorkbookIO.Origin | null>;
+    /**
+     * Strips a known file extension from a file name, returning the base name.
+     *
+     * @internal
+     */
+    protected _stripExtension(fileName: string): string;
+    /**
+     * Returns the last path/URL segment of a name without its extension, or `null` if not provided.
+     * Handles both file paths and URLs (e.g. `'https://host/a/report.xlsx'` -> `'report'`).
+     *
+     * @internal
+     */
+    protected _baseName(pathOrUrl: string | null | undefined): string | null;
+    protected _writeArrayBuffer<T extends IWorkbookIO.WriteOptions = IWorkbookIO.WriteOptions>(workbook: IWorkbook, writeType: IWorkbookIO.WriteFormatType, options?: T): Promise<ArrayBufferLike>;
+    protected _readArrayBuffer<T extends IWorkbookIO.ReadOptions = IWorkbookIO.ReadOptions>(arrayBuffer: ArrayBufferLike, format: IWorkbookIO.ReadFormatType, options?: T): Promise<IWorkbook>;
+}
+/**
+ * A singleton instance of the default {@link IWorkbookIO} implementation.
+ */
+export declare const WorkbookIO: IWorkbookIO;
+//# sourceMappingURL=WorkbookIO.d.ts.map

package/types/src/io/WorkbookOrigin.d.ts

@@ -0,0 +1,114 @@
+import { IListener } from '../listener';
+import { IWorkbookIO } from './IWorkbookIO';
+/**
+ * Options for constructing a {@link WorkbookOrigin}.
+ */
+export interface WorkbookOriginOptions {
+    /**
+     * Explicit display name (without extension). If omitted, the name is derived from the path.
+     */
+    name?: string | null;
+    /**
+     * The resolved format key (e.g. `'xlsx'`) — the handle's resource type. If omitted, it is
+     * derived from the path extension.
+     */
+    format?: string | null;
+    /**
+     * The last-known size of the source in bytes (stat-style), if known.
+     */
+    size?: number | null;
+    /**
+     * Whether the source can be written back to (a silent re-save).
+     *
+     * @defaultValue `true` for a local path, `false` for an unbound (`null`) path or a remote
+     * (`http(s):`/`data:`/`blob:`) one.
+     */
+    canWrite?: boolean;
+    /**
+     * The encryption envelope the source is wrapped in, or `null` for plaintext.
+     */
+    encryption?: string | null;
+}
+/**
+ * Default, observable {@link IWorkbookIO.Origin} implementation vended by the IO layer — the
+ * concrete "light virtual file handle" (see `IO-DESIGN.md`).
+ *
+ * @remarks
+ * Mutable and observable: the IO/store layer holds the instance and calls {@link update} when the
+ * source moves (a save that resolved a destination) or is renamed, firing `onChange` so holders —
+ * including the workbook itself, whose `getName()`/`onNameChange` derive from this — propagate it.
+ * Source logic (paths, URLs, formats) lives here, in the IO layer, not in the workbook model.
+ *
+ * An **unbound** origin (`path: null`) belongs to an in-memory workbook with no destination yet; a
+ * destination-resolving save fills it in place via {@link update}.
+ */
+export declare class WorkbookOrigin implements IWorkbookIO.Origin {
+    private _path;
+    private _name;
+    private _format;
+    private _size;
+    private _canWrite;
+    private _encryption;
+    /**
+     * The session password for this source. Deliberately not in {@link toString}, not serialized, and
+     * not reachable through the {@link IWorkbookIO.Origin} interface — see {@link getPassword}.
+     */
+    private _password;
+    private readonly _emitter;
+    constructor(path?: string | null, options?: WorkbookOriginOptions);
+    /** An unbound path can't be written back; neither can a remote one (without a store that can). */
+    private static _defaultCanWrite;
+    /** Drops any query/fragment so a URL path resolves to a clean file segment. */
+    private _cleanPath;
+    /** {@inheritDoc IWorkbookIO.Origin.getName} */
+    getName(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.getPath} */
+    getPath(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.getFormat} */
+    getFormat(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.getExtension} */
+    getExtension(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.getEncryption} */
+    getEncryption(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.isEncrypted} */
+    isEncrypted(): boolean;
+    /** {@inheritDoc IWorkbookIO.Origin.setPassword} */
+    setPassword(password: string | null): void;
+    /**
+     * The session password, or `null`.
+     *
+     * @remarks
+     * The **privileged read channel**, deliberately on the class and not on the
+     * {@link IWorkbookIO.Origin} interface — the same arrangement as {@link update}. Only the IO layer
+     * uses it, to encrypt on write; consumers can set a password but never read one back.
+     */
+    getPassword(): string | null;
+    /** {@inheritDoc IWorkbookIO.Origin.getSize} */
+    getSize(): number | null;
+    /** {@inheritDoc IWorkbookIO.Origin.canWrite} */
+    canWrite(): boolean;
+    /** {@inheritDoc IWorkbookIO.Origin.setName} */
+    setName(name: string | null): void;
+    /**
+     * Update one or more fields in place. Fires `onChange` if anything actually changed.
+     *
+     * @remarks
+     * This is the **privileged mutation channel** (see `IO-DESIGN.md`): permitted callers are the
+     * backing store (rename/move, destination resolution), the IO layer (filling an unbound origin on
+     * a first destination-resolving save), and the document layer (Save As / rename). Never format
+     * handlers, never the model, never chrome.
+     */
+    update(next: {
+        path?: string | null;
+        name?: string | null;
+        format?: string | null;
+        size?: number | null;
+        canWrite?: boolean;
+        encryption?: string | null;
+    }): this;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IWorkbookIO.Origin.IListeners, options?: IListener.Options): IListener.Remove;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+//# sourceMappingURL=WorkbookOrigin.d.ts.map

package/types/src/io/WorkbookRegistry.d.ts

@@ -0,0 +1,49 @@
+import { IWorkbookIO } from './IWorkbookIO';
+export declare class WorkbookRegistry implements IWorkbookIO.Registry {
+    private _readFormats;
+    private _writeFormats;
+    private _encryptions;
+    /** @inheritdoc IWorkbookIO.registerReadFormat */
+    registerReadFormat(formatType: IWorkbookIO.ReadFormatType): Promise<void>;
+    /** @inheritdoc IWorkbookIO.registerWriteFormat */
+    registerWriteFormat(formatType: IWorkbookIO.WriteFormatType): Promise<void>;
+    /** @inheritdoc IWorkbookIO.Registry.registerEncryption */
+    registerEncryption(encryption: IWorkbookIO.EncryptionType): Promise<void>;
+    /**
+     * The registered envelope to *write* with: the one matching `key`, or the first registered when
+     * no key is given.
+     *
+     * @remarks
+     * A key is supplied when re-saving a file that is already encrypted, so it is rewritten in the
+     * scheme it arrived in rather than silently migrated.
+     */
+    getEncryption(key?: string | null): Promise<IWorkbookIO.EncryptionType | null>;
+    /** {@inheritDoc WorkbookRegistry.getEncryption} — synchronous; the list is already in hand. */
+    peekEncryption(key?: string | null): IWorkbookIO.EncryptionType | null;
+    /**
+     * The registered encryption envelope wrapping these bytes, or `null` if they are plaintext (or no
+     * envelope recognizes them).
+     *
+     * @remarks
+     * Detection is by content, never by extension: an encrypted `.xlsx` and an encrypted `.sxl` are
+     * the same container, and neither announces itself in its name.
+     */
+    detectEncryption(bytes: ArrayBufferLike): Promise<IWorkbookIO.EncryptionType | null>;
+    getReadFormats(options?: IWorkbookIO.GetFormatsOptions): Promise<IWorkbookIO.ReadFormatType[]>;
+    getWriteFormats(options?: IWorkbookIO.GetFormatsOptions): Promise<IWorkbookIO.WriteFormatType[]>;
+    protected _registerFormatType<T extends IWorkbookIO.FormatType>(format: T, formats: readonly T[]): Promise<readonly T[]>;
+    protected _registerFormatTypeSync<T extends IWorkbookIO.FormatType>(format: T, formats: readonly T[]): readonly T[];
+    /**
+     * Returns a filtered array of formats using AND logic for all provided options.
+     *
+     * @remarks
+     * - All filters are applied with AND logic (format must match ALL conditions)
+     * - If ext is not provided, defaultExt is used as fallback
+     * - Extension matching is case-insensitive and handles formats with/without leading dot
+     * - Tag filtering requires ALL specified tags to be present
+     *
+     * @internal
+     */
+    protected _filterFormats<T extends IWorkbookIO.FormatType>(options: IWorkbookIO.GetFormatsOptions, formats: readonly T[], defaultExt?: string): T[];
+}
+//# sourceMappingURL=WorkbookRegistry.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './IWorkbookIO';
+export * from './WorkbookIO';
+export * from './WorkbookOrigin';
+export * from './ArrayBackingStore';
+//# sourceMappingURL=index.d.ts.map

package/types/src/lib/file/file.browser.d.ts

@@ -0,0 +1,41 @@
+import { IWorkbook } from '../../workbook';
+import { IWorkbookIO } from '../../io/IWorkbookIO';
+import { AbstractBackingStore } from '../../io/AbstractBackingStore';
+/**
+ * The browser {@link IWorkbookIO.IBackingStore}. Reads via a file the caller supplies (or an
+ * open picker when none is given) and writes via the File System Access API
+ * (`showSaveFilePicker`), falling back to a download when the API is unavailable.
+ *
+ * @remarks
+ * The writable file-system handle behind an {@link IWorkbookIO.Origin} is held in a private
+ * per-instance cache **keyed by the origin**, so a save to a bound origin can re-write silently.
+ * This is an invisible optimization — a handle cannot be recreated from a string path, so holding
+ * the object is the only way to re-save in place. Nothing about it is surfaced through any public
+ * type; the origin's `canWrite()` reflects whether a handle is held.
+ */
+export declare class BrowserBackingStore extends AbstractBackingStore {
+    private _getWriteFormats;
+    private _getReadFormats?;
+    protected _defaultStringSourceType: "fetch";
+    /** Writable FSA handles keyed by the Origin they back. */
+    private _handleCache;
+    private _pendingOpenHandle;
+    constructor(_getWriteFormats: () => Promise<IWorkbookIO.FormatType[]>, _getReadFormats?: (() => Promise<IWorkbookIO.FormatType[]>) | undefined);
+    /** @inheritdoc IWorkbookIO.IBackingStore.read */
+    read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
+    /** @inheritdoc */
+    protected resolveSource(): Promise<any>;
+    /** @inheritdoc */
+    protected onWorkbookRead(workbook: IWorkbook): Promise<void>;
+    /** @inheritdoc */
+    protected filePathToFile(filePath: string): Promise<File>;
+    /** @inheritdoc IWorkbookIO.IBackingStore.write */
+    write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
+}
+export { BrowserBackingStore as DefaultBackingStore };
+/**
+ * Browser implementation throws an error since browsers cannot access local filesystem.
+ * Users should use file input elements instead.
+ */
+export declare function filePathToFile(filePath: string): Promise<File>;
+//# sourceMappingURL=file.browser.d.ts.map

package/types/src/lib/file/file.node.d.ts

@@ -0,0 +1,25 @@
+import { IWorkbookIO } from '../../io/IWorkbookIO';
+import { AbstractBackingStore } from '../../io/AbstractBackingStore';
+/**
+ * The node {@link IWorkbookIO.IBackingStore}. Reads from local paths via `fs`, and writes to the
+ * destination {@link IWorkbookIO.Origin} handle. Node has no interactive picker, so a
+ * destination-resolving write (an unbound or read-only handle) falls back to the suggested name in
+ * the current directory when the handle at least carries a name, and throws otherwise.
+ */
+export declare class FSBackingStore extends AbstractBackingStore {
+    constructor(_getWriteFormats?: () => Promise<IWorkbookIO.FormatType[]>, _getReadFormats?: () => Promise<IWorkbookIO.FormatType[]>);
+    /** @inheritdoc */
+    protected filePathToFile(filePath: string): Promise<File>;
+    /** @inheritdoc */
+    protected _canWriteLocalPath(): boolean;
+    /** @inheritdoc IWorkbookIO.IBackingStore.write */
+    write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
+}
+export { FSBackingStore as DefaultBackingStore };
+/**
+ * Reads a file from the local filesystem and returns a File object.
+ * Node.js implementation using fs.
+ * Returns a File object with the full resolved path as the name.
+ */
+export declare function filePathToFile(filePath: string): Promise<File>;
+//# sourceMappingURL=file.node.d.ts.map

package/types/src/lib/utils/_Utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Two-tier node fingerprint.
+ * - `stable`: hash of fields unlikely to change (arch, osType, platform, memoryGB).
+ *   Used for hard enforcement.
+ * - `full`: hash that also includes hostname.
+ *   Passes silently if stable matches but full diverges (hostname rename, container re-creation).
+ */
+export interface NodeFingerprint {
+    stable: string;
+    full: string;
+}
+export interface HostDetails {
+    cpus?: number;
+    memoryGB?: number;
+    domain?: string | null;
+    fingerprint?: NodeFingerprint;
+}
+export declare function getBuildVersion(): string;
+export declare function getBuildDate(): string;
+//# sourceMappingURL=_Utils.d.ts.map

package/types/src/lib/utils/banner.d.ts

@@ -0,0 +1,6 @@
+export declare const BANNER_IMAGE = "\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\n\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D\u2588\u2588\u2551\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551\n\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551     \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551    \u2588\u2588\u2554\u255D \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\n\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D    \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D";
+export declare const BANNER_TEXT: string;
+export declare const sheetXLBlue = "#1976d2";
+export declare const sheetXLRed = "#E12929";
+export declare const sheetXLYellow = "#FFA726";
+//# sourceMappingURL=banner.d.ts.map

package/types/src/lib/utils/utils.browser.d.ts

@@ -0,0 +1,28 @@
+import { HostDetails } from './_Utils';
+import { LicenseDetails } from '../../license';
+export declare function getHostDetails(): Promise<HostDetails>;
+export declare function isDevEnv(): Promise<boolean>;
+/**
+ * The runtime location - the current page url in the browser.
+ */
+export declare function getLocation(): string;
+/**
+ * The OS platform, used by the `INFO("system")` formula.
+ */
+export declare function getOS(): string;
+export declare function findLicenseKey(): Promise<{
+    key: string;
+    from: string;
+} | null>;
+export declare function setKey(key: string, force?: boolean): Promise<void>;
+export declare function getKey(): Promise<string>;
+export declare function printBanner(isUser: boolean): Promise<void>;
+/**
+ * The browser always gets the full banner — there is no piped output to protect, and
+ * the console collapses repeats. (See the node variant for the throttled CLI behavior.)
+ */
+export declare function claimFullLicensePrint(): Promise<boolean>;
+/** The one-line form of the unlicensed notice; in the browser only the activation pointer. */
+export declare function printLicenseNotice(): Promise<void>;
+export declare function printDetails(details: LicenseDetails, isUser?: boolean, expanded?: boolean, ignoreExceptions?: boolean): Promise<void>;
+//# sourceMappingURL=utils.browser.d.ts.map

package/types/src/lib/utils/utils.node.d.ts

@@ -0,0 +1,42 @@
+import { HostDetails } from './_Utils';
+import { LicenseDetails } from '../../license';
+export declare function getHostDetails(): Promise<HostDetails>;
+export declare function isDevEnv(): Promise<boolean>;
+/**
+ * The runtime location - the current working directory in node.
+ */
+export declare function getLocation(): string;
+/**
+ * The OS platform, used by the `INFO("system")` formula. `process.platform` is available
+ * synchronously without importing `os`.
+ */
+export declare function getOS(): string;
+export declare function findLicenseKey(): Promise<{
+    key: string;
+    from: string;
+} | null>;
+export declare function setKey(key: string, force?: boolean): Promise<void>;
+export declare function getKey(): Promise<string | undefined>;
+export declare function printBanner(isUser: boolean): Promise<void>;
+/**
+ * Whether an automatic license print may use the full banner (art + details), as opposed to
+ * the one-line notice. Claims the slot when granting it.
+ *
+ * @remarks
+ * The full form is for a human, and not on every run: stderr must be an interactive terminal
+ * (`isTTY` is `undefined` when piped/redirected/captured) and the art must not have run within
+ * the throttle window, persisted alongside the license key store. Fails open — no store means
+ * the full banner prints.
+ */
+export declare function claimFullLicensePrint(): Promise<boolean>;
+/**
+ * The one-line form of the unlicensed notice.
+ *
+ * @remarks
+ * One line on stderr: visible in logs and terminals without ever touching the payload stream,
+ * and cheap where the ASCII banner would be noise (a pipe, CI, an agent's context window).
+ * Dim when a human is watching stderr, plain ANSI-free text when not.
+ */
+export declare function printLicenseNotice(): Promise<void>;
+export declare function printDetails(details: LicenseDetails, isUser?: boolean, expanded?: boolean, ignoreExceptions?: boolean): Promise<void>;
+//# sourceMappingURL=utils.node.d.ts.map

package/types/src/license/LicenseDetails.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @hidden
+ */
+export interface LicenseDetails {
+    getLicensee(): string | null;
+    getExpiration(): Date | null;
+    getDomains(): string[];
+    getCpuCount(): number;
+    getMemory(): number;
+    isEval(): boolean;
+    isValidFor: (feature: string) => boolean;
+    getDeveloperCount(): number;
+    getType(): string;
+    getExceptions(): string[];
+    hasExceptions(): boolean;
+    isValid(): boolean;
+    getFeatures(): Readonly<Record<string, string>>;
+    getKeyFrom(): string;
+    getBuildVersion(): string;
+    getBuildDate(): string;
+}
+//# sourceMappingURL=LicenseDetails.d.ts.map

package/types/src/license/LicenseManager.d.ts

@@ -0,0 +1,63 @@
+import { LicenseDetails } from './LicenseDetails';
+declare class LM {
+    constructor();
+    /**
+     * Set the license key provided by SheetXL.
+     * @remarks
+     * The license key can also be provided via a file named `sheetxl.lic` in the root of the web server.
+     *
+     * @param licenseKey The license key as a string.
+     * @param force If set to `true` will replace an existing key.
+     *
+     * @see
+     * {@link https://www.sheetxl.com/docs/guides/getting-started/license-key | License Keys}
+     */
+    setLicenseKey(licenseKey: string, force?: boolean): Promise<LicenseDetails>;
+    private _validate;
+    private _printDetails;
+    private _doPrint;
+    private _print;
+    /**
+     * Return the current license details.
+     */
+    getDetails(): Promise<LicenseDetails>;
+    /**
+     * Print just the banner
+     */
+    print(expanded?: boolean): Promise<void>;
+    wasPrinted(): boolean;
+    /**
+     * Disable printing of the banner for a period of time.
+     *
+     * @param The reason for suppressing the license
+     *
+     * @remarks
+     * Call this to disable the license key watermark for a period of time.
+     * This is useful for testing purposes.
+     */
+    suppressPrint(reason: string): void;
+    /**
+     * Print just the banner.
+     */
+    printBanner(): Promise<void>;
+    /**
+     * Print the current license details.
+     */
+    printDetails(expanded?: boolean, ignoreExceptions?: boolean): Promise<LicenseDetails>;
+    /**
+     * Generate a unique identifier for node.
+     *
+     * @remarks
+     * This will return `null` in the browser.
+     */
+    getFingerprint(): Promise<string>;
+}
+/**
+ * LicenseManager is used to manage license keys at runtime.
+ *
+ * License keys can be generated by visiting {@link https://www.sheetxl.com/docs/guides/getting-started/license-key | License Keys}.
+ */
+declare const LicenseManager: LM;
+export default LicenseManager;
+export { LicenseManager };
+//# sourceMappingURL=LicenseManager.d.ts.map

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

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

package/types/src/license/license-key.d.ts

@@ -0,0 +1,33 @@
+import { LicenseDetails } from './LicenseDetails';
+export interface Decoded {
+    licensee?: string | null;
+    type?: string;
+    expiry?: number;
+    developerCount?: number;
+    domains?: string[];
+    fingerprint?: string | null;
+    cpuCount?: number;
+    memory?: number | null;
+    features?: Record<string, any>[];
+}
+export interface LicenseAndKey {
+    details: LicenseDetails;
+    key: string;
+}
+export interface LicenseKeyDetails {
+    licensee: string;
+    type?: string;
+    expiration?: string | null;
+    developerCount?: number;
+    domains?: string | string[];
+    fingerprint?: string | null;
+    cpuCount?: number | null;
+    memory?: number | null;
+    features?: Record<string, any> | null;
+}
+export declare function rot(text: string, key: number, n?: number): string;
+export declare function deobs(str: string): Decoded;
+export declare function encodeLicenseKey(keyDetails: LicenseKeyDetails): LicenseAndKey;
+export declare function validateDomain(domain: string, allowDomain?: boolean): boolean;
+export declare function validateFingerprint(fingerprint: string | null): boolean;
+//# sourceMappingURL=license-key.d.ts.map

package/types/src/listener/IListener.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Namespace used for listeners to events.
+ */
+export declare namespace IListener {
+    /**
+     * A callback for the listener.
+     */
+    interface Callback<S> {
+        (source: S, params?: any): any;
+    }
+    /**
+     * The listener objects
+     */
+    type Callbacks<SOURCE, EVENTS = any> = Partial<{
+        [Property in keyof EVENTS]: IListener.Callback<SOURCE>;
+    }>;
+    /**
+     * Additional options for a listener.
+     */
+    interface Options {
+        /**
+         * If true, the listener will be removed after the first time it is called.
+         *
+         * @defaultValue false;
+         */
+        once?: boolean;
+        /**
+         * Determines if the listeners is part of the transaction.
+         *
+         * @defaultValue If the listener is added during a transaction this will be true.
+         *
+         * @remarks
+         * There are subtle differences between a transactional listener and a non-transactional listener.
+         *
+         * A transactional listener:
+         * * Will not be fire during undo/redo.
+         * * Will be reverted to it's original add/remove state during an undo/redo.
+         *
+         * A non-transactional listener:
+          * Will not be fire on any change.
+         */
+        transactional?: boolean;
+    }
+    interface Remove {
+        (): void;
+    }
+    interface ISource<SOURCE, EVENTS = any> {
+        /**
+         * Add a set of callbacks to receive notification.
+         *
+         * @param listeners The callbacks object.
+         * @param options Options
+         * @returns A function that can be called to remove the listener.
+         *
+         * @remarks
+         * Listeners are fired in the order that they are added.
+         *
+         */
+        addListeners(listeners: IListener.Callbacks<SOURCE, EVENTS>, options?: IListener.Options): IListener.Remove;
+    }
+}
+//# sourceMappingURL=IListener.d.ts.map