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

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

@@ -1,25 +1,46 @@
 import { LicenseDetails } from './LicenseDetails';
+/**
+ * Where a license runs. `browser` is any page (checked against its origin); `server` is any
+ * JavaScript runtime outside a browser - Node, Bun, Deno, the CLI, a CI runner (checked against the
+ * machine).
+ */
+export type LicenseRuntime = 'browser' | 'server';
+export declare const LICENSE_RUNTIMES: readonly LicenseRuntime[];
 export interface Decoded {
     licensee?: string | null;
     type?: string;
     expiry?: number;
     developerCount?: number;
+    /** The runtimes the key covers; `undefined` for a key issued before runtimes were explicit. */
+    runtimes?: LicenseRuntime[];
     domains?: string[];
     fingerprint?: string | null;
     cpuCount?: number;
     memory?: number | null;
     features?: Record<string, any>[];
 }
+/**
+ * The runtimes a decoded key covers. A key issued before runtimes were explicit covers `browser`
+ * when it has origins, and `server` unless its cpu and memory are both 0 (the old browser-only
+ * marker).
+ */
+export declare function getRuntimes(decoded: Decoded): LicenseRuntime[];
 export interface LicenseAndKey {
     details: LicenseDetails;
     key: string;
 }
 export interface LicenseKeyDetails {
     licensee: string;
-    type?: string;
+    type?: string | null;
     expiration?: string | null;
     developerCount?: number;
-    domains?: string | string[];
+    /**
+     * The runtimes the key covers. Defaults to what the other terms imply: `browser` when there are
+     * origins, `server` when there is a fingerprint, cpu count or memory.
+     */
+    runtimes?: LicenseRuntime[] | null;
+    /** Licensed origins, `<protocol>://<host>` each (see `Origin`); a string is comma-separated. */
+    domains?: string | string[] | null;
     fingerprint?: string | null;
     cpuCount?: number | null;
     memory?: number | null;
@@ -29,5 +50,31 @@ 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;
+/**
+ * A licensed origin, `<protocol>://<host>`.
+ *
+ * The protocol is the scheme the page is served over — `https` on the web, `vscode-webview` in VS Code
+ * desktop, an app's own registered scheme in Electron — and is mandatory: a browser license names
+ * the runtime it was sold for, not just a hostname. The host is a domain (matched exactly or as a
+ * suffix — `acme.com` covers `app.acme.com`), `*` for any host (runtimes whose host is random, like
+ * VS Code's `v--<hash>`), or empty for schemes that carry no host (`file://`).
+ */
+export interface Origin {
+    protocol: string;
+    host: string;
+}
+/** Splits `<protocol>://<host>`; `null` when the entry has no protocol or a malformed one. */
+export declare function parseOrigin(entry: string): Origin | null;
+/**
+ * `true` when `entry` is a well-formed origin. Web hosts (`http`/`https`) must be a subdomain, or an
+ * apex when the license carries the `domain` feature (`allowDomain`) — the same rule `validateDomain`
+ * applies; any other scheme accepts a DNS-shaped host, `*`, or none.
+ */
+export declare function validateOrigin(entry: string, allowDomain?: boolean): boolean;
+/**
+ * `true` when the running page — `protocol` without its colon and `hostname`, as `location` reports
+ * them — is covered by `entry`. An entry with no protocol covers nothing.
+ */
+export declare function originMatches(entry: string, protocol: string, hostname: string): boolean;
 export declare function validateFingerprint(fingerprint: string | null): boolean;
 //# sourceMappingURL=license-key.d.ts.map

package/types/src/license/runtime.browser.d.ts

@@ -0,0 +1,41 @@
+import { HostDetails, LicenseKeySource } from './Types';
+import { LicenseDetails } from './LicenseDetails';
+/**
+ * What the license check sees of the page: the scheme it is served over (no colon) and its hostname.
+ * `domain` is `null` for the one dev case — loopback over http(s). The scheme is part of that test on
+ * purpose: `tauri://localhost` / `capacitor://localhost` are shipped apps that happen to use a loopback
+ * host, and are checked like production. Outside a window (a worker, node under test) both are `null`.
+ */
+export declare function getHostDetails(): Promise<HostDetails>;
+/**
+ * Only the loopback host over http(s) is a dev environment. A dev *build* served on any other host
+ * (a LAN IP, a tunnel) — or under any other scheme — is checked exactly like production: license
+ * origins apply and an evaluation shows the watermark.
+ */
+export declare function isDevEnv(): Promise<boolean>;
+/**
+ * The key in the nearest `sheetxl.lic` served at or above the page. When the server cannot be
+ * reached, the key last read from any of those locations; with none cached, `unreachable`.
+ */
+export declare function readLicenseKey(): Promise<LicenseKeySource>;
+/**
+ * An evaluation: unrestricted on localhost, and with the evaluation watermark anywhere else.
+ */
+export declare function getEvalLicense(keyFrom: string): Promise<LicenseDetails>;
+/**
+ * The license for this page when the host set no key: the key file's, an evaluation when there is
+ * none, or `unavailable` when it could not be loaded.
+ */
+export declare function getLicense(): Promise<LicenseDetails>;
+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=runtime.browser.d.ts.map

package/types/src/{lib/utils/utils.node.d.ts → license/runtime.node.d.ts}

@@ -1,20 +1,17 @@
-import { HostDetails } from './_Utils';
-import { LicenseDetails } from '../../license';
+import { HostDetails, LicenseKeySource } from './Types';
+import { LicenseDetails } from './LicenseDetails';
 export declare function getHostDetails(): Promise<HostDetails>;
 export declare function isDevEnv(): Promise<boolean>;
+export declare function readLicenseKey(): Promise<LicenseKeySource>;
 /**
- * The runtime location - the current working directory in node.
+ * An evaluation: runs with the unlicensed notice.
  */
-export declare function getLocation(): string;
+export declare function getEvalLicense(keyFrom: string): Promise<LicenseDetails>;
 /**
- * The OS platform, used by the `INFO("system")` formula. `process.platform` is available
- * synchronously without importing `os`.
+ * The license for this process when the host set no key: the environment's or the stored key's,
+ * or an evaluation.
  */
-export declare function getOS(): string;
-export declare function findLicenseKey(): Promise<{
-    key: string;
-    from: string;
-} | null>;
+export declare function getLicense(): Promise<LicenseDetails>;
 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>;
@@ -39,4 +36,4 @@ export declare function claimFullLicensePrint(): Promise<boolean>;
  */
 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
+//# sourceMappingURL=runtime.node.d.ts.map

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

@@ -25,19 +25,24 @@ export declare namespace IListener {
          */
         once?: boolean;
         /**
-         * Determines if the listeners is part of the transaction.
+         * Whether the listener takes part in the operation that notifies it.
          *
-         * @defaultValue If the listener is added during a transaction this will be true.
+         * @defaultValue `true` when the listener is added during an operation - a listener added as a
+         * consequence of one is part of it - and `false` otherwise.
          *
          * @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.
+         * * is told inline, inside the operation, so anything it writes joins that same commit, and
+         *   is told during an undo or a redo for the same reason;
+         * * hears nothing announced outside an operation;
+         * * is part of the document: the operation that added it removes it on undo and puts it back
+         *   on redo.
          *
          * A non-transactional listener:
-          * Will not be fire on any change.
+         * * is told once per operation, after it has landed, however many times the operation
+         *   notified, and not at all if the operation is rolled back;
+         * * is told at once when there is no operation, and at once during an undo or a redo;
+         * * survives an undo, since it is not part of the document.
          */
         transactional?: boolean;
     }

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

@@ -3,16 +3,34 @@ import { IListener } from './IListener';
 export interface NotifyOptions<T = any> {
     params?: T | null;
     source?: any;
+    /**
+     * Collect what the listeners return. A notify that collects is a request, not an
+     * announcement, and is delivered at once wherever it is made.
+     */
     async?: boolean;
+    /**
+     * Deliver as if made inside (`true`) or outside (`false`) an operation, whatever the store
+     * says. `false` is for a signal that is not a change to the document (a dirty flag).
+     */
     transactional?: boolean;
 }
 /**
- * Manages Listeners
+ * Manages listeners.
  *
  * @remarks
- * A few rules to know:
+ * `transactional` ({@link IListener.Options}) says whether a listener takes part in the operation
+ * that notifies it. Unless the caller says, it is inferred from where the listener was added: one
+ * added as a consequence of an operation is part of it.
  *
- * * non-transactional listeners are fired after the commit end and are conflated.
+ * * A transactional listener is told inline, inside the operation, so what it writes joins that
+ *   commit; it is told during a restore's dispatch for the same reason. It is versioned with the
+ *   document - an undo removes the subscription, a redo restores it - and, being part of an
+ *   operation, it hears nothing announced outside one.
+ * * A non-transactional listener is told ONCE, after the operation has landed, with everything
+ *   the operation announced conflated by callback; a rollback drops it. Outside an operation, and
+ *   during a restore, it is told at once - a restore has no commit to wait for.
+ * * A request (`async`) is delivered at once wherever it is made and returns what the listeners
+ *   answered. A question is not an announcement, and deferring one would break every `await`.
  */
 export declare class ListenerEmitter<SOURCE, EVENTS> {
     protected _transactions: ITransaction.IStore;
@@ -22,10 +40,32 @@ export declare class ListenerEmitter<SOURCE, EVENTS> {
     protected _src: SOURCE;
     protected _listeners: EntrySet<SOURCE, EVENTS>;
     protected _pending: Pending<any, SOURCE>[] | null;
+    protected _landing: Pending<any, SOURCE>[] | null;
     constructor(src: SOURCE, transactions?: ITransaction.IStore);
+    /** DEBUG (temporary): names this emitter in the `__SXL_LOG_EVENTS` trace. Remove with it. */
+    protected _label(): string;
+    /**
+     * `true` while the store is mid-operation: a transaction is open, or a restore is being
+     * dispatched. What a listener added now is a consequence of, and what a notify made now belongs
+     * to.
+     */
+    protected _inOperation(): boolean;
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: IListener.Callbacks<SOURCE, EVENTS>, options?: IListener.Options): IListener.Remove;
+    /**
+     * Write the transactional listener set, copy-on-write, as a fold rather than a step.
+     *
+     * @remarks
+     * The set is document state, so a subscription made by an operation is removed by undoing it
+     * and put back by redoing it. A fold rather than a commit because a registration is not a step
+     * in the history: it adds no undo entry and announces nothing. Inside an open operation the
+     * flag is a no-op on the nested commit and the write simply joins that operation, which is
+     * where a listener added as a consequence of it belongs.
+     */
+    protected _updateEntries(mutate: (entries: EntrySet<SOURCE, EVENTS>) => void): void;
     protected _doNotify<T = unknown>(listeners: IListener.Callback<SOURCE>[], removes?: IListener.Remove[] | null, options?: NotifyOptions<T>, fired?: Set<IListener.Callback<SOURCE>>): Promise<any>;
+    /** The callbacks for `key` in a bucket, gathered first so a removal during delivery is safe. */
+    protected _collect(entries: EntrySet<SOURCE, EVENTS> | undefined, key: keyof EVENTS): Collected<SOURCE> | null;
     /**
      * Notify listeners.
      */
@@ -37,10 +77,11 @@ interface Entry<SOURCE, EVENTS> {
     listeners: IListener.Callbacks<SOURCE, EVENTS>;
 }
 type EntrySet<SOURCE = any, EVENTS = any> = Set<Entry<SOURCE, EVENTS>>;
-interface Pending<T, SOURCE> {
-    commitId: string;
+interface Collected<SOURCE> {
     listeners: IListener.Callback<SOURCE>[];
     removes: IListener.Remove[] | null;
+}
+interface Pending<T, SOURCE> extends Collected<SOURCE> {
     options?: NotifyOptions<T>;
 }
 export {};

package/types/src/model/AbstractModel.d.ts

@@ -5,7 +5,7 @@ import { ListenerEmitter } from '../listener/ListenerEmitter';
 /**
  * Abstract implement of `IModel`.
  */
-export declare abstract class AbstractModel<STATE extends AbstractModel.State = AbstractModel.State, JSON extends any = any, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = IModel.Events> implements IModel {
+export declare abstract class AbstractModel<STATE extends AbstractModel.State = AbstractModel.State, JSON extends any = any, EVENTS extends IModel.Events = IModel.Events> implements IModel {
     protected _emitter: ListenerEmitter<AbstractModel, EVENTS>;
     protected _options: IModel.ConstructorOptions<JSON>;
     protected _transactions: ITransaction.IStore;
@@ -38,16 +38,27 @@ export declare abstract class AbstractModel<STATE extends AbstractModel.State =
     /** @internal */
     protected _getTransactions(): ITransaction.IStore;
     /** @internal */
+    /** Write the state as a step in the history. */
     protected _updateState(updateState?: Partial<STATE>, //(prevState: STATE) => STATE,
     options?: ITransaction.StoreOperationOptions, events?: (keyof EVENTS)[]): this;
+    /**
+     * Write the state as a fold into the commit it starts from, rather than as a step.
+     *
+     * @remarks
+     * For a write that is not an edit - this model's own initialization, or bookkeeping derived
+     * from a change that already has a commit. It adds no undo entry and is undone with the commit
+     * it lands in. See {@link ITransaction.amend}.
+     */
+    protected _amendState(updateState?: Partial<STATE>, options?: ITransaction.StoreOperationOptions, events?: (keyof EVENTS)[]): this;
+    private _writeState;
     /** @internal */
     protected _getEmitter<SOURCE, E extends EVENTS>(): ListenerEmitter<SOURCE, E>;
     /** @internal */
     protected _processInit(): void;
     /** @internal */
-    protected _processAfterStateChange(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processAfterStateChange(_state: STATE, _commit: ITransaction.ICommit): void;
     /** @internal */
-    protected _processRestoreOrRevert(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processRestoreOrRevert(_state: STATE, _commit: ITransaction.ICommit): void;
     delete(options?: ITransaction.OperationOptions): void;
     /** @internal */
     protected _delete(options?: ITransaction.OperationOptions): void;
@@ -84,7 +95,5 @@ export declare namespace AbstractModel {
     interface State extends ITransaction.StateRecord {
         isDeleted: boolean;
     }
-    interface CommitView {
-    }
 }
 //# sourceMappingURL=AbstractModel.d.ts.map

package/types/src/movable/AbstractMovableContent.d.ts

@@ -0,0 +1,182 @@
+import { IRange } from '@sheetxl/primitives';
+import { AbstractModel, IModel } from '../model';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ICalculation } from '../calculation/ICalculation';
+import { IStyleCollection } from '../style';
+import { IMovable } from './IMovable';
+/**
+ * What every content shares: its name, its description, the movable that places it, and the
+ * cells it names.
+ *
+ * @remarks
+ * A kind that names cells - a chart's series, a control's linked cell - hands each formula to
+ * {@link _addWatch} and keeps the handle. The base does the rest: {@link getReferences} is the
+ * union of what the engine holds for every watch, {@link IMovable.ContentEvents.onReferencesChange}
+ * is announced each time the engine rewrites one, a delete releases every watch inside its own
+ * commit, and an undone delete holds them again. A kind with nothing to name calls nothing.
+ */
+export declare abstract class AbstractMovableContent<STATE extends AbstractMovableContent.State = AbstractMovableContent.State, JSON extends any = any, EVENTS extends IMovable.ContentEvents = IMovable.ContentEvents> extends AbstractModel<STATE, JSON, EVENTS> implements IMovable.IContent {
+    /** Numbers the default names: `Chart 3`. */
+    static instanceCounter: number;
+    private _getMovable;
+    private _addWatchOption;
+    private _getRangeOption;
+    private _watches;
+    /** The watches are out of the engine because the content is deleted; a restore holds them again. */
+    private _watchesReleased;
+    constructor(options: AbstractMovableContent.ConstructorOptions<JSON>);
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    abstract getTypeDescription(): string;
+    /** {@inheritDoc IMovable.IContent.getName} */
+    getName(): string | null;
+    /** {@inheritDoc IMovable.IContent.setName} */
+    setName(name: string): this;
+    /** {@inheritDoc IMovable.IContent.getDescription} */
+    getDescription(): string | null;
+    /** {@inheritDoc IMovable.IContent.setDescription} */
+    setDescription(description: string | null): this;
+    /** {@inheritDoc IMovable.IContent.getMovable} */
+    getMovable(): IMovable | null;
+    /** {@inheritDoc IMovable.IContent.getReferences} */
+    getReferences(): ICellRanges | null;
+    /**
+     * Hands a formula the content names to the calculation engine, which keeps its references on
+     * the cells they name through inserts, deletes, cuts, sheet renames and undo.
+     *
+     * @param formula The expression, or a formula - the one a watch delivered before, when the
+     *                content holds again what it had.
+     * @param callback Receives the engine's formula once it holds the body, and again after every
+     *                 change to its text; `event.formula.getExpression()` is the text as it reads now.
+     * @param options Where a relative endpoint is authored, and whether the body is evaluated.
+     *
+     * @returns Removes the watch. The handle is the watch's identity: a kind that maps a watch to a
+     *          field of its JSON keeps its own handle-to-field map.
+     *
+     * @remarks
+     * Without the seam (content outside a workbook) nothing is held: the callback is never called,
+     * and {@link getReferences} resolves the expression as given.
+     * @internal
+     */
+    protected _addWatch(formula: ICalculation.IFormula | string, callback?: (event: AbstractMovableContent.WatchEvent) => void, options?: AbstractMovableContent.WatchOptions): IListener.Remove;
+    /** The range `address` names in the content's workbook, or `null` when it names none or there is no workbook. @internal */
+    protected _resolveRange(address: string): ICellRange | null;
+    private _hold;
+    /**
+     * `expression` as one plain reference, for a content the engine holds nothing for. A bare
+     * address is on the content's own sheet.
+     */
+    private _parseReference;
+    private _notifyReferencesChange;
+    /** Inside the delete's own commit, so an undo brings the references back with the content. */
+    private _releaseWatches;
+    /** From what each watch last read: the formula the engine delivered, else the text as given. */
+    private _holdWatches;
+    /** @internal */
+    protected _processDelete(): void;
+    /** @internal */
+    protected _processRestoreOrRevert(state: STATE, commit: ITransaction.ICommit): void;
+    /**
+     * The id the file gave this content (`cNvPr/@id`), which a connector's glued ends name it by;
+     * `undefined` for content that has none yet. Kept on the content's `data`; a kind that keeps it
+     * elsewhere overrides this and {@link _ensureSourceId} together.
+     * @internal
+     */
+    _getSourceId(): number | undefined;
+    /**
+     * The id the file writes this content with, taking one from `next` when it has none yet: what a
+     * connector's end names it by, written as part of the open operation.
+     * @internal
+     */
+    _ensureSourceId(next: () => number): number;
+    /** @internal */
+    protected _protectionCheck(description: string): void;
+}
+/**
+ * Interfaces for creating movable content.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link AbstractMovableContent}
+ */
+export declare namespace AbstractMovableContent {
+    interface State extends AbstractModel.State {
+        name?: string | null;
+        description?: string | null;
+    }
+    /**
+     * What a watch delivers: see {@link ConstructorOptions.addWatch}.
+     */
+    interface WatchEvent {
+        /**
+         * The formula as the engine holds it. Its expression is the text as it reads now; its
+         * references are the cells it names now.
+         */
+        formula: ICalculation.IFormula;
+        /**
+         * The body's values, for a watch that evaluates ({@link WatchOptions.evaluate}).
+         */
+        values?: IRange;
+    }
+    /**
+     * Options for {@link ConstructorOptions.addWatch}.
+     */
+    interface WatchOptions {
+        /**
+         * Evaluate the body and deliver its values after every pass that changed them. Off, the
+         * watch is a hold: the body demands its first cell only, so holding a reference to a column
+         * costs one read a pass, not the column.
+         *
+         * @defaultValue `false`
+         */
+        evaluate?: boolean;
+        /**
+         * Where a relative endpoint of the formula is authored.
+         *
+         * @defaultValue The content's anchor top-left when the watch registers.
+         */
+        origin?: IRange.CellCoords;
+    }
+    /**
+     * Hands a formula the content names to the calculation engine; see
+     * {@link ConstructorOptions.addWatch}.
+     */
+    type AddWatch = (formula: ICalculation.IFormula | string, callback: (event: WatchEvent) => void, options?: WatchOptions) => IListener.Remove;
+    interface ConstructorOptions<J> extends IModel.ConstructorOptions<J> {
+        /**
+         * The name. Content that a movable places is given one when this is empty.
+         */
+        name?: string | null;
+        /**
+         * The alternative text.
+         */
+        description?: string | null;
+        /**
+         * Returns the movable that places the content. Not provided for content that has none.
+         */
+        getMovable?: () => IMovable | null;
+        /**
+         * Returns the styles the content's theme references resolve against. Not provided for
+         * content outside a workbook.
+         */
+        getStyles?: () => IStyleCollection | null;
+        /**
+         * Hands a formula the content names to the calculation engine, which keeps its references
+         * on the cells they name through inserts, deletes, cuts, sheet renames and undo, and calls
+         * back with the formula each time its text changes. The same contract as
+         * {@link ICellRanges.addWatch} without the range: a content has no location its formulas are
+         * evaluated over, only its anchor.
+         *
+         * Not provided for content outside a workbook; its references then read as set.
+         */
+        addWatch?: AddWatch;
+        /**
+         * Resolves an address against the workbook the content lives in. Not provided for content
+         * outside a workbook.
+         */
+        getRange?: (address: string) => ICellRange | null;
+    }
+}
+//# sourceMappingURL=AbstractMovableContent.d.ts.map

package/types/src/movable/CustomElement.d.ts

@@ -1,17 +1,16 @@
 import { IResource, IResourceCollection } from '../resource';
-import { IModel, AbstractModel } from '../model';
 import { ICustomElement } from './ICustomElement';
-interface State extends AbstractModel.State {
+import { AbstractMovableContent } from './AbstractMovableContent';
+interface State extends AbstractMovableContent.State {
     data?: any;
     type: string;
 }
 /**
  * Implementation for {@link ICustomElement}.
  */
-export declare class CustomElement extends AbstractModel<State, ICustomElement.JSON> implements ICustomElement {
+export declare class CustomElement extends AbstractMovableContent<State, ICustomElement.JSON> implements ICustomElement {
     constructor(options: CustomElement.ConstructorOptions);
     getType(): string;
-    getDescription(): string;
     toJSON(_toResourceId?: (resource: IResource) => number | null): ICustomElement.JSON | null;
     getTypeDescription(): string;
 }
@@ -27,7 +26,7 @@ export declare namespace CustomElement {
     /**
      * Options for creating a Custom Element.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<ICustomElement.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<ICustomElement.JSON> {
         /**
          * Returns an IResource from the resourceId or null if not found.
          */

package/types/src/movable/ErrorContent.d.ts

@@ -0,0 +1,49 @@
+import { IErrorContent } from './IErrorContent';
+import { CustomElement } from './CustomElement';
+/**
+ * Implementation for {@link IErrorContent}: the content's JSON as it was read, kept for the save,
+ * and the reason the content could not be made.
+ */
+export declare class ErrorContent extends CustomElement implements IErrorContent {
+    private readonly _error;
+    private readonly _originalType;
+    constructor(options: ErrorContent.ConstructorOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IErrorContent.getError} */
+    getError(): unknown;
+    /** {@inheritDoc IErrorContent.getOriginalType} */
+    getOriginalType(): string;
+    /**
+     * The type the movable saves this content under: the original, so a save writes back what was
+     * read.
+     * @internal
+     */
+    _getSavedType(): string;
+    /** {@inheritDoc IModel.isReadOnly} */
+    isReadOnly(): boolean;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IErrorContent.isIErrorContent} */
+    get isIErrorContent(): true;
+}
+/**
+ * Interfaces for creating `ErrorContent`.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link ErrorContent}
+ */
+export declare namespace ErrorContent {
+    /**
+     * Options for creating an error content.
+     */
+    interface ConstructorOptions extends CustomElement.ConstructorOptions {
+        /** The type of the content that could not be made. */
+        type: string;
+        /** Why it could not be made. */
+        error: unknown;
+    }
+}
+//# sourceMappingURL=ErrorContent.d.ts.map