@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

package/types/src/transaction/Transaction.d.ts

@@ -0,0 +1,184 @@
+import { IListener } from '../listener';
+import { ITransaction } from './ITransaction';
+/**
+ * Thrown when an operation with an `expectedCommitId` precondition can not begin.
+ *
+ * @remarks
+ * `stale` — the store's current commit no longer matches (another operation committed first).
+ * `open` — a transaction was already open, so the head could move beneath the operation.
+ */
+export declare class TransactionConflictError extends Error {
+    /** Why the optimistic check failed. */
+    readonly reason: 'stale' | 'open';
+    /** The commit id the operation expected to be current. */
+    readonly expectedCommitId: string;
+    /** The commit id that was actually current. */
+    readonly actualCommitId: string;
+    constructor(reason: 'stale' | 'open', expectedCommitId: string, actualCommitId: string);
+}
+interface CommitRecord {
+    id?: string;
+    description?: string | null;
+    meta: Record<string, string>;
+    timestamp: number;
+    author?: any;
+    states: Map<string, any>;
+    operation?: ITransaction.Operation<any>;
+    viewBefore?: Record<string, any> | null;
+    viewAfter?: Record<string, any> | null;
+    previousId?: string | null;
+    version: number;
+}
+interface CommitContainer {
+    record: CommitRecord;
+    commit: ITransaction.ICommit;
+}
+/**
+ * Events are never fired on sub transactions. Only when making changes to the root
+ * either directly or through a final commit. Any models that want to fire non transactional
+ * events should do this directly.
+ */
+export declare class TransactionStore implements ITransaction.IStore {
+    protected _listeners: Set<ITransaction.IListeners>;
+    protected _listenersState: Map<any, Set<ITransaction.IStateListener>>;
+    protected _commits: Map<string, CommitContainer>;
+    protected _transactionStack: AbstractTransaction[];
+    protected _transactionOpen: boolean;
+    protected _locked: boolean;
+    protected _isSync: boolean;
+    protected _isTransient: boolean;
+    protected _author: any;
+    protected _maxCommits: number;
+    /**
+     * The latest *committed* id — unlike `_current` it does NOT move on restore/revert, so a
+     * commit on a restored (non-tip) state is detectable as a branch: the segment from the tip
+     * back to that state is the orphaned redo branch, unreachable once the undo manager clears
+     * its redo stack on the new operation, and is pruned.
+     */
+    protected _tipId: string;
+    protected _current: CommitContainer;
+    protected _pending: CommitContainer | null;
+    protected _cacheId: string | null;
+    protected _cacheState: any;
+    protected _states: Map<string, any>;
+    /**
+     * Single store-lifetime version sequence, bumped once per (non-elided) commit; every record
+     * written in that commit is stamped with the same id. It is an *identity*, not a per-record
+     * count — a record's versionId increases with each committed write but is not sequential.
+     * Deliberately NOT a snapshot: after a restore the *snapshot* versions roll back
+     * (`getVersionId`) but new commits keep drawing from here, so an id from an undone redo
+     * branch is never reissued.
+     */
+    protected _versionCounter: number;
+    constructor(options?: ITransaction.StoreConstructorOptions);
+    /**
+     * Sets the transaction store to be synchronous or asynchronous.
+     *
+     * @param sync
+     *
+     * @remarks
+     * This is used for unit tests only.
+     */
+    static setDefaultSync: (sync: boolean) => void;
+    /** {@inheritDoc ITransaction.IStore.getLog} */
+    getLog(commitId: string, max?: number): ITransaction.ICommit[];
+    /** {@inheritDoc ITransaction.IStore.getCommitCount} */
+    getCommitCount(): number;
+    /** {@inheritDoc ITransaction.IStore.isOpenTransaction} */
+    isOpenTransaction(): boolean;
+    /** {@inheritDoc ITransaction.IStore.getView} */
+    getPendingView(): Record<string, any> | null;
+    /** {@inheritDoc ITransaction.IStore.create} */
+    create<STATE = any>(initial?: Readonly<STATE>): string;
+    /** {@inheritDoc ITransaction.IStore.getState} */
+    getState<STATE = any>(stateId: string): Readonly<STATE>;
+    /** {@inheritDoc ITransaction.IStore.getCurrentCommit} */
+    getCurrentCommit(includePending?: boolean): ITransaction.ICommit;
+    /** {@inheritDoc ITransaction.IStore.getTipCommit} */
+    getTipCommit(): ITransaction.ICommit;
+    /** {@inheritDoc ITransaction.IStore.getVersionId} */
+    getVersionId(stateId: string): number;
+    /** {@inheritDoc ITransaction.IStore.restore} */
+    restore(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
+    /** {@inheritDoc ITransaction.IStore.revert} */
+    revert(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
+    protected _getCommitContainer(commitId: string, options?: ITransaction.RestoreOptions): CommitContainer;
+    /**
+     * Remove the orphaned redo branch: every commit from the tip back to (exclusive) `untilId`.
+     * Only called when a commit lands on a restored, non-tip state (a natural branch). Safe
+     * because the undo manager clears its redo stack whenever a new operation is added, so
+     * nothing can reference the orphans.
+     */
+    protected _pruneForwards(untilId: string): void;
+    /**
+     * Enforce `maxCommits`: drop the oldest commits beyond the cap and null the link at the
+     * cut so `getLog` terminates cleanly (a restore to a dropped commit fails with invalid id).
+     */
+    protected _trimOldest(): void;
+    /** {@inheritDoc ITransaction.IStore.beginCommit} */
+    beginCommit(options?: ITransaction.StoreOperationOptions | string, onClose?: ITransaction.CloseCallback): ITransaction;
+    /** {@inheritDoc ITransaction.IStore.doBatch} */
+    doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): Promise<R> | R;
+    /** {@inheritDoc ITransaction.IStore.remove} */
+    remove(stateId: string): boolean;
+    /** {@inheritDoc ITransaction.IStore.addListener} */
+    addListener(listener: ITransaction.IListeners): IListener.Remove;
+    /** {@inheritDoc ITransaction.IStore.addStateListener} */
+    addStateListener<State = any, View = any>(stateId: string, listener: ITransaction.IStateListener<State, View>): IListener.Remove;
+    protected dispatchEvents(dispatcher: () => void, async?: boolean): void | Promise<any>;
+    protected _commitRecord(container: CommitContainer, states: Map<any, any>, forceAmend: boolean): void;
+    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, view?: Record<string, any> | null, isRevert?: boolean, isRestore?: boolean, async?: boolean): void;
+    _notify(event: keyof ITransaction.IListeners, commit: ITransaction.ICommit, async?: boolean): void | Promise<any>;
+}
+declare abstract class AbstractTransaction implements ITransaction {
+    protected _store: TransactionStore;
+    protected _states: Map<string, any>;
+    protected _description: string;
+    protected _meta: Record<string, string>;
+    protected _children: Set<AbstractTransaction>;
+    protected _depth: number;
+    protected _descriptions?: string[];
+    protected _container: CommitContainer;
+    protected _closed: boolean;
+    protected _readOnly: boolean;
+    constructor(store: TransactionStore, container: CommitContainer, options: ITransaction.StoreOperationOptions | string | undefined);
+    /** {@inheritDoc ITransaction.getView} */
+    getView(): Record<string, any> | null;
+    /** {@inheritDoc ITransaction.getState} */
+    abstract getState<STATE = any>(model: any): STATE;
+    /** {@inheritDoc ITransaction.rollback} */
+    abstract rollback(): ITransaction;
+    /** {@inheritDoc ITransaction.getParent} */
+    abstract getParent(): ITransaction;
+    /** {@inheritDoc ITransaction.getId} */
+    abstract getId(): string;
+    /** {@inheritDoc ITransaction.getDepth} */
+    getDepth(): number;
+    /** {@inheritDoc ITransaction.getDescription} */
+    getDescription(): string;
+    /** {@inheritDoc ITransaction.getStates} */
+    getStates(): Map<any, any>;
+    /** {@inheritDoc ITransaction.beginTransaction} */
+    beginTransaction(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
+    /**
+     * Whether this transaction was declared read-only ({@link ITransaction.OperationOptions.readOnly}).
+     * Inherited by nested transactions; they cannot opt back out.
+     */
+    isReadOnly(): boolean;
+    /** {@inheritDoc ITransaction.updateState} */
+    updateState<STATE = any>(stateId: string, state: Readonly<Partial<STATE>> | ((prev: Readonly<STATE>) => Readonly<STATE>)): STATE;
+    /** {@inheritDoc ITransaction.commit} */
+    commit(options?: ITransaction.StoreOperationOptions): ITransaction;
+    /** {@inheritDoc ITransaction.isClose} */
+    isClose(): boolean;
+    protected _ensureOpen(): void;
+    _removeChild(child: AbstractTransaction, isRollback?: boolean): void;
+    /**
+     * Purge a record from this transaction (and children). Used by the store's `remove`.
+     * @internal
+     */
+    _purgeState(id: string): void;
+    protected _mergeStates(statesChild: Map<string, any>): Map<string, any> | undefined;
+}
+export {};
+//# sourceMappingURL=Transaction.d.ts.map

package/types/src/transaction/TransactionSaveStateManager.d.ts

@@ -0,0 +1,85 @@
+import { IListener } from '../listener';
+import { ITransaction } from './ITransaction';
+/**
+ * Tracks whether a transactional root — a `Workbook`, or a standalone `Sheet` — has unsaved
+ * changes, by comparing the store's current commit against a *saved bookmark* commit.
+ *
+ * @remarks
+ * A peer to {@link TransactionUndoManager}: both attach to an {@link ITransaction.IStore} and
+ * interpret its commits. This one answers "am I dirty relative to the last save?".
+ *
+ * Dirty is a pure commit-id comparison, which has two nice consequences for free:
+ * * Undoing back to the saved commit becomes clean again (the store restores the prior commit id).
+ * * Selection / view-only changes are non-transactional, so they never create a commit and never
+ *   mark the root dirty.
+ *
+ * It is consumer-owned: construct it, and call {@link close} when done. It is intentionally never
+ * attached to the model. Pass an {@link ITransaction.ICommitSource} (e.g. `WorkbookIO`) and it marks
+ * itself clean automatically on a matching persist; otherwise call {@link markSaved} directly.
+ */
+export declare class TransactionSaveStateManager implements IListener.ISource<TransactionSaveStateManager, TransactionSaveStateManager.IListeners> {
+    private _store;
+    private _emitter;
+    /** The commit id considered "saved". Dirty is `current !== this`. */
+    private _savedCommitId;
+    /** Cached dirty value so we only notify on a transition. */
+    private _dirty;
+    private _removeStoreListener;
+    private _removeCommitListener?;
+    /**
+     * @param store The store of the transactional root to track. A freshly read / created root is
+     *   clean (the bookmark is initialized to the current commit).
+     * @param commitSource Optional source of durable-commit notifications (e.g. `WorkbookIO`). When
+     *   given, a matching persist (same store) marks this manager clean — no per-consumer wiring.
+     */
+    constructor(store: ITransaction.IStore, commitSource?: ITransaction.ICommitSource);
+    /** The store this manager tracks. */
+    getStore(): ITransaction.IStore;
+    /** `true` when the current commit differs from the saved bookmark. */
+    isDirty(): boolean;
+    /** The commit id currently treated as saved, or `null`. */
+    getSavedCommitId(): string | null;
+    /**
+     * Move the saved bookmark, marking the root clean as of `commitId`.
+     *
+     * @param commitId The commit that was persisted. Defaults to the current commit.
+     *
+     * @remarks
+     * Pass the commit captured when the bytes were *encoded* (not when the write completed), so edits
+     * made during an async write correctly leave the root dirty.
+     */
+    markSaved(commitId?: string | null): void;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: TransactionSaveStateManager.IListeners, options?: IListener.Options): IListener.Remove;
+    private _recompute;
+    /**
+     * Detach the store / commit listeners and release listeners.
+     */
+    close(): void;
+}
+/**
+ * {@inheritDoc TransactionSaveStateManager}
+ */
+export declare namespace TransactionSaveStateManager {
+    /**
+     * Events fired by a {@link TransactionSaveStateManager}.
+     */
+    interface Events {
+        /**
+         * Called when the root transitions from clean to dirty (the first change since the last save).
+         *
+         * @param source The manager.
+         */
+        onDirty?(source: TransactionSaveStateManager): void;
+        /**
+         * Called when the root transitions from dirty to clean (saved, or undone back to the saved
+         * state).
+         *
+         * @param source The manager.
+         */
+        onClean?(source: TransactionSaveStateManager): void;
+    }
+    interface IListeners extends IListener.Callbacks<TransactionSaveStateManager, Events> {
+    }
+}
+//# sourceMappingURL=TransactionSaveStateManager.d.ts.map

package/types/src/transaction/TransactionUndoManager.d.ts

@@ -0,0 +1,60 @@
+import { UndoManager } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+/**
+ * An {@link UndoManager} that is a *view over the transaction store's commit log*, not a mirror
+ * of it.
+ *
+ * @remarks
+ * The store already models undo: the chain behind the current commit is the undo stack, the
+ * segment from the current commit forward to the tip is the redo stack, and committing on a
+ * restored state prunes that forward branch (the redo-clearing rule). Deriving each answer from
+ * the log on demand means the stack can never lag the store — an `undo()` issued in the same
+ * tick as an edit acts on the commit that edit just made. (The event-fed mirror this replaces
+ * registered operations from `onCommitEnd`, which the store dispatches a tick late; an immediate
+ * undo raced it and silently acted on a stale stack.) It is also the shape that extends to
+ * collaboration: a per-author stack is a filter over the same log.
+ *
+ * Commits without a description are not offered as undo points (elided transactions); their
+ * changes revert alongside the nearest described commit.
+ */
+export declare class TransactionUndoManager extends UndoManager {
+    private _transactions;
+    private _removeListener?;
+    /** Commits at-or-before this point predate the manager (or the last {@link clear}) and are not undoable. */
+    private _floorId;
+    constructor(transactions?: ITransaction.IStore, maxStack?: number);
+    /**
+     * Described commits undoable from the current point, most recent first.
+     *
+     * @remarks
+     * Always walks the full chain: `getLog` re-roots at the `maxCommits` cut, so an unbounded walk
+     * is guaranteed to terminate at a root — which is exactly the commit that cannot be reverted
+     * (nothing precedes it). A bounded walk could not tell "hit the max" from "hit the root".
+     */
+    private _undoCommits;
+    /** Described commits redoable toward the tip, nearest first. */
+    private _redoCommits;
+    undo(count?: number): void;
+    redo(count?: number): void;
+    hasUndo(): boolean;
+    hasRedo(): boolean;
+    getTopUndoDescription(): string | null;
+    getTopRedoDescription(): string | null;
+    getUndoDescriptions(): readonly string[];
+    getRedoDescriptions(): readonly string[];
+    /**
+     * The commit log is the stack; arbitrary operations cannot be added.
+     * Perform work through a described transaction instead.
+     */
+    addUndoOperation(): never;
+    /**
+     * Forget the current history: commits at-or-before this point stop being undoable.
+     * The commits themselves remain in the store.
+     */
+    clear(notify?: boolean): void;
+    /**
+     * Close the undo manager and remove the listener.
+     */
+    close(): void;
+}
+//# sourceMappingURL=TransactionUndoManager.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './ITransaction';
+export * from './Transaction';
+export * from './TransactionUndoManager';
+export * from './TransactionSaveStateManager';
+//# sourceMappingURL=index.d.ts.map

package/types/src/type/ICollection.d.ts

@@ -0,0 +1,110 @@
+import { JSONSerializableAsync } from '@sheetxl/utils';
+import { IListener } from '../listener';
+/**
+ * Interface used for all ICollections.
+ */
+export interface ICollection<T> {
+    /**
+     * Iterates the collection's items.
+     *
+     * @remarks
+     * The unfiltered walk — `for (const sheet of wb.getSheets())`. Every other iterable surface in
+     * the SDK (`ICellRange`, `ICellRegions`, `ICellRanges`) reads this way, so a collection that did
+     * not was a trap: `for…of` over one is the obvious line to write and it threw at runtime with
+     * nothing in the types to warn first.
+     *
+     * {@link getItems} remains the call that takes options — filtering, ordering, anything
+     * parameterized. This is sugar over the unfiltered case, not a replacement for it.
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * Returns the items in the collection.
+     */
+    getItems(options?: ICollection.GetItemsOptions): T[];
+    /**
+     * Returns the total items available.
+     *
+     * @remarks
+     * returns the total number of items available.
+     */
+    getCount(): number;
+}
+/**
+ * {@inheritDoc ICollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ICollection}
+ */
+export declare namespace ICollection {
+    /**
+     * Options for getting items from the collection.
+     *
+     * @remarks
+     * This placeholder is extended by implementations of ICollection
+     */
+    interface GetItemsOptions {
+    }
+    /**
+     * Collection that can be persisted.
+     */
+    interface IPersistable<J = any> {
+        /**
+         * Used for saving items. Returns a handler that will allow for writing JSON records
+         * only save the items that were accessed within the persist scope.
+         */
+        beginPersist(): ICollection.IPersistScope<J>;
+    }
+    /**
+     * A transient scope for items to ids that can be used for references.
+     *
+     * @see
+     * {@link IPersistable.beginPersist}
+     */
+    interface IPersistScope<J = any> {
+        /**
+         * For a shared string this will return a number that can be used to reference the item in the persisted json.
+         * @param item The to return an identifier for.
+         */
+        add(item: JSONSerializableAsync<J> | J): number | null;
+        /**
+         * For a given persist id this will return the item.
+         *
+         * @param id
+         */
+        at(id: number): JSONSerializableAsync<J> | J | null;
+        /**
+         * Called when done persisting.
+         */
+        endPersist(): void;
+        /**
+         * Loads the json.
+         *
+         * @param json
+         */
+        fromJSON(json: J[]): void;
+        /**
+         * Return a array of resources that have been added via `add`.
+         *
+         * @remarks
+         * This can be called multiple times..
+         */
+        toJSONAsync(): Promise<J[]>;
+    }
+    /**
+     * Collection Events.
+     */
+    interface Events {
+        /**
+         * Called when collections have changes.
+         */
+        onCollectionChange?(source: ICollection<any>): void;
+        /**
+         * Called when the collection has been updated due to a undo/redo and a rerender is required.
+         */
+        onInvalidated?(source: ICollection<any>): void;
+    }
+    interface IListeners extends IListener.Callbacks<ICollection<any>, ICollection.Events> {
+    }
+}
+//# sourceMappingURL=ICollection.d.ts.map

package/types/src/type/IProperties.d.ts

@@ -0,0 +1,51 @@
+import { Scalar, IRange } from '@sheetxl/primitives';
+/**
+ * Contains interfaces for working with properties.
+ */
+export declare namespace IProperties {
+    /**
+     * Represents an interface for ranged items with customizable properties,
+     * supporting operations such as retrieving properties at a given coordinate,
+     * cloning with updates, splitting, and merging.
+     *
+     * @typeParam P - The type representing the properties associated with the range.
+     * @typeParam U - The type accepted by updates. This need not be `P` widened - a property bag may
+     * accept convenience keys that are folded onto canonical ones and never appear in `P` (see
+     * `IStyledFont.Modifiers`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
+     * @typeParam J - The type representing the JSON-serializable representation of the range.
+     */
+    interface ICellRanged<P, U = IProperties.ResolvableProperties<P>> {
+        /**
+         * Retrieves the coordinates for the range.
+         *
+         * @returns The range's coordinates.
+         *
+         * @remarks
+         * The coordinates are not the coordinates where this is contained but the coordinates for access getPropertiesAt.
+         */
+        getCoords(): Readonly<IRange.Coords>;
+        /**
+         * Retrieves the properties associated with a specified cell within the range.
+         *
+         * @param rowIndex The row index within the range.
+         * @param colIndex The column index within the range.
+         * @param value The value at the coordinates.
+         * @returns The properties associated with the specified cell as a read-only object.
+         */
+        getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<P>;
+        /**
+         * Creates a new instance of the range with specified updates applied.
+         *
+         * @param updates The updates to apply to the range's properties.
+         * @returns A new `ICellRanged` instance with the applied updates.
+         */
+        cloneWithUpdate?(updates: U): this;
+    }
+    /**
+     * Recursively converts a type into a derived type where any field can be a string or a function that takes the old value.
+     */
+    type ResolvableProperties<T> = Partial<{
+        [Property in keyof T]: T[Property] | string | null | ResolvableProperties<T[Property]>;
+    }>;
+}
+//# sourceMappingURL=IProperties.d.ts.map

package/types/src/type/ITypes.d.ts

@@ -0,0 +1,69 @@
+import { RunCoords, Bounds, RangeCoords } from '@sheetxl/utils';
+/**
+ * A collection of types.
+ */
+export declare namespace ITypes {
+    /**
+     * Associate an optional value with a {@link RangeCoords}.
+     */
+    interface RangeCoordValue<T = any> extends RangeCoords {
+        value?: T;
+    }
+    /**
+     * Associate an option value with a {@link RunCoords}.
+     */
+    interface RunCoordValue<T> extends RunCoords {
+        value?: T;
+    }
+    /**
+     * Associate an option value with a {@link Bounds}.
+     */
+    interface BoundsValue<T = any> extends Bounds {
+        value?: T;
+    }
+    /**
+     * How a formula's array extent is to be interpreted.
+     *
+     * @remarks
+     * There are three on-disk formula states, not two, and the extent means a different thing in
+     * each:
+     *
+     * * `dynamic` - the extent is *derived from* the result. It spills, and it resizes when the
+     *   result shape changes.
+     * * `dynamicSpillError` - a `dynamic` formula whose spill is currently blocked. The recorded
+     *   extent collapses to the anchor cell.
+     * * `static` - legacy array-entered (Ctrl+Shift+Enter). The extent is *authoritative* and the
+     *   result is fitted to it; it never spills and never resizes.
+     *
+     * `static + spillError` is not a state: a stored fixed block owns its cells, so a spill
+     * collision is rejected at entry rather than detected at calc. That is what lets these three be
+     * one enum rather than two booleans.
+     */
+    type FormulaArrayKind = 'dynamic' | 'dynamicSpillError' | 'static';
+    /**
+     * Options for controlling selection behavior, including scrolling and focus.
+     */
+    interface SelectOptions {
+        /**
+         * If `true` or if a valid `ScrollIntoViewOptions` object is provided,
+         * the selected element will be scrolled into view.
+         *
+         * @remarks
+         * - If a `ScrollIntoViewOptions` object is provided, it will control the exact scrolling behavior.
+         * - If `false` (or omitted), the selected element will not be scrolled into view.
+         *
+         * @defaultValue false
+         */
+        scrollIntoView?: boolean | globalThis.ScrollIntoViewOptions;
+        /**
+         * If `true`, the selected element will automatically receive focus after being selected.
+         *
+         * @remarks
+         * - If `false` (or omitted), the element will not automatically receive focus.
+         *
+         * @defaultValue false
+         */
+        autoFocus?: boolean;
+    }
+}
+//# sourceMappingURL=ITypes.d.ts.map

package/types/src/type/Registry.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Registry for managing items by key.
+ *
+ * @remarks
+ * Provides registration and lookup by name. Pre-populated with built-ins.
+ * Supports custom registration for extensibility.
+ */
+export declare class Registry<T extends IRegisterable> {
+    private readonly _items;
+    constructor(builtins: Record<string, T>);
+    /**
+     * Register a custom operator or selector.
+     *
+     * @param item The operator or selector to register.
+     *
+     * @remarks
+     * Overwrites any existing registration with the same name.
+     * Use this to add custom operators/selectors or override built-ins.
+     *
+     * @example
+     * ```ts
+     * const customOperator: ICondition.IOperator = {
+     *   getName: () => 'myCustomOperator',
+     *   createPredicate: (criteria, ctx) => (value) => value > 100
+     * };
+     * Condition.Operators.register(customOperator);
+     * ```
+     */
+    register(item: T): void;
+    /**
+     * Get an operator or selector by name.
+     *
+     * @param name The name of the operator or selector (e.g., "greaterThan", "wholeNumber").
+     * @returns The operator/selector instance, or `undefined` if not found.
+     *
+     * @remarks
+     * Used for deserialization and runtime lookup by string name.
+     *
+     * @example
+     * ```ts
+     * const selector = Condition.Selectors.get('wholeNumber');
+     * const operator = Condition.Operators.get('greaterThan');
+     * ```
+     */
+    get(name: string): T | undefined;
+    /**
+     * Get all registered operators or selectors.
+     *
+     * @returns Array of all registered items.
+     *
+     * @remarks
+     * Useful for populating UI dropdowns or iterating over all available options.
+     */
+    getAll(): T[];
+    /**
+     * Check if an operator or selector is registered.
+     *
+     * @param name The name to check.
+     * @returns `true` if registered, `false` otherwise.
+     */
+    has(name: string): boolean;
+}
+export interface IRegisterable {
+    getName(): string;
+}
+//# sourceMappingURL=Registry.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './ITypes';
+export * from './IProperties';
+export * from './ICollection';
+export * from './Registry';
+//# sourceMappingURL=index.d.ts.map