@signaldb/svelte 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/base/core/src/Collection/Observer.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isEqual_1 = __importDefault(require("../utils/isEqual"));
+const uniqueBy_1 = __importDefault(require("../utils/uniqueBy"));
+const queryDelta_1 = require("../utils/queryDelta");
+/**
+ * Represents an observer that tracks changes in a collection of items and triggers
+ * callbacks for various events such as addition, removal, and modification of items.
+ * @template T - The type of the items being observed, which must include an `id` field.
+ */
+class Observer {
+    previousItems = [];
+    callbacks;
+    unbindEvents;
+    /**
+     * Creates a new instance of the `Observer` class.
+     * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
+     * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
+     */
+    constructor(bindEvents) {
+        this.callbacks = {
+            added: [],
+            addedBefore: [],
+            changed: [],
+            changedField: [],
+            movedBefore: [],
+            removed: [],
+        };
+        this.unbindEvents = bindEvents();
+    }
+    call(event, ...args) {
+        this.callbacks[event].forEach(({ callback, options }) => {
+            // execute only if it's not initial call or if initial call should not be skipped
+            if (!options.skipInitial || !options.isInitial) {
+                callback(...args);
+            }
+        });
+    }
+    hasCallbacks(events) {
+        return events.some(event => this.callbacks[event].length > 0);
+    }
+    /**
+     * Determines if the observer has no active callbacks registered for any events.
+     * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
+     */
+    isEmpty() {
+        return !this.hasCallbacks([
+            'added',
+            'addedBefore',
+            'changed',
+            'changedField',
+            'movedBefore',
+            'removed',
+        ]);
+    }
+    /**
+     * Compares the previous state of items with the new state and triggers the appropriate callbacks
+     * for events such as added, removed, changed, or moved items.
+     * @param getItems - A function that returns a promise resolving to the new items or the items themselves.
+     */
+    runChecks(getItems) {
+        const result = getItems();
+        if (result instanceof Promise) {
+            result
+                .then(newItems => this.checkItems(newItems))
+                .catch((error) => {
+                // eslint-disable-next-line no-console
+                console.error('Error while asynchronously querying items', error);
+            });
+        }
+        else {
+            this.checkItems(result);
+        }
+    }
+    /**
+     * Brings the observer up to date from a description of what changed, instead of from the new
+     * result.
+     *
+     * `runChecks` has to rediscover the change by comparing the whole new result against the whole
+     * old one — a cost proportional to the result, paid on every write, to find out that one row
+     * moved. When the change is already known it can simply be reported, and the cost becomes
+     * proportional to the change.
+     *
+     * The delta must have been computed against exactly the result this observer holds. If it was
+     * not, this reports nothing, falls back to `runChecks`, and returns `false`.
+     *
+     * Note that the reported moves are minimal, where a comparison reports every item whose
+     * neighbour changed. Applying them yields the same order either way — there are simply fewer of
+     * them.
+     * @param delta - The change to report.
+     * @param getItems - Used to fall back to a comparison when the delta cannot be applied.
+     * @returns Whether the delta was applied.
+     */
+    applyDelta(delta, getItems) {
+        if (!(0, queryDelta_1.canApplyQueryDelta)(this.previousItems, delta)) {
+            this.runChecks(getItems);
+            return false;
+        }
+        if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
+            return true;
+        this.emitDelta(delta, (0, queryDelta_1.applyQueryDelta)(this.previousItems, delta));
+        return true;
+    }
+    /**
+     * Reports a delta and adopts the result it produces.
+     *
+     * The single place the callbacks are fired from, whether the change arrived as a delta or was
+     * found by comparing two results — so the two can never disagree about what a consumer is told.
+     * @param delta - The change to report.
+     * @param nextItems - The result the delta produces.
+     */
+    emitDelta(delta, nextItems) {
+        if (this.isEmpty()) {
+            this.finishCheck(nextItems);
+            return;
+        }
+        const beforeOf = (index) => nextItems[index + 1] || null;
+        // Indexing the previous result costs its whole length, and most deltas do not need it: an item
+        // that changed is reported by its new value, and only a listener asking which *field* changed,
+        // or one asking about a removal, needs to see what was there before.
+        const needsPreviousItems = (delta.removed.length > 0 && this.hasCallbacks(['removed']))
+            || (delta.changed.length > 0 && this.hasCallbacks(['changedField']));
+        const previousById = needsPreviousItems
+            ? new Map(this.previousItems.map(item => [item.id, item]))
+            : null;
+        if (this.hasCallbacks(['changed', 'changedField'])) {
+            delta.changed.forEach((item) => {
+                this.call('changed', item);
+                if (!this.hasCallbacks(['changedField']))
+                    return;
+                const oldItem = previousById?.get(item.id);
+                if (!oldItem)
+                    return;
+                const keys = (0, uniqueBy_1.default)([
+                    ...Object.keys(item),
+                    ...Object.keys(oldItem),
+                ], value => value);
+                keys.forEach((key) => {
+                    if ((0, isEqual_1.default)(item[key], oldItem[key]))
+                        return;
+                    this.call('changedField', item, key, oldItem[key], item[key]);
+                });
+            });
+        }
+        if (this.hasCallbacks(['removed'])) {
+            delta.removed.forEach((id) => {
+                const oldItem = previousById?.get(id);
+                if (oldItem)
+                    this.call('removed', oldItem);
+            });
+        }
+        if (this.hasCallbacks(['added', 'addedBefore'])) {
+            delta.added.forEach(({ index, item }) => {
+                this.call('added', item);
+                this.call('addedBefore', item, beforeOf(index));
+            });
+        }
+        if (this.hasCallbacks(['movedBefore'])) {
+            delta.moved.forEach(({ index }) => {
+                this.call('movedBefore', nextItems[index], beforeOf(index));
+            });
+        }
+        this.finishCheck(nextItems);
+    }
+    finishCheck(newItems) {
+        // Store new items as previous items for next check
+        this.previousItems = newItems;
+        Object.keys(this.callbacks).forEach((key) => {
+            const event = key;
+            const callbacks = this.callbacks[event];
+            this.callbacks[event] = callbacks.map(callback => ({
+                ...callback,
+                options: {
+                    ...callback.options,
+                    isInitial: false,
+                },
+            }));
+        });
+    }
+    checkItems(newItems) {
+        // Derives the change and reports it through the same path a change that arrived ready-made
+        // takes. Comparing and then reporting item by item, as this used to, meant the two paths could
+        // describe the same change differently — most visibly in how many moves they reported.
+        this.emitDelta((0, queryDelta_1.diffQueryResults)(this.previousItems, newItems), newItems);
+    }
+    stopped = false;
+    /**
+     * Stops the observer by unbinding all events and cleaning up resources.
+     * Safe to call multiple times - will only unbind once.
+     */
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.unbindEvents();
+    }
+    /**
+     * Registers callbacks for specific events to observe changes in the collection.
+     * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
+     * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
+     */
+    addCallbacks(callbacks, skipInitial = false) {
+        Object.keys(callbacks).forEach((key) => {
+            const typedKey = key;
+            this.callbacks[typedKey].push({
+                callback: callbacks[typedKey],
+                options: { skipInitial, isInitial: true },
+            });
+        });
+    }
+    /**
+     * Removes the specified callbacks for specific events, unregistering them from the observer.
+     * @param callbacks - An object containing the callbacks to be removed for various events.
+     */
+    removeCallbacks(callbacks) {
+        Object.keys(callbacks).forEach((key) => {
+            const typedKey = key;
+            const index = this.callbacks[typedKey]
+                .findIndex(({ callback }) => callback === callbacks[typedKey]);
+            this.callbacks[typedKey].splice(index, 1);
+        });
+    }
+}
+exports.default = Observer;

package/dist/base/core/src/Collection/index.d.ts

@@ -0,0 +1,341 @@
+import type ReactivityAdapter from '../types/ReactivityAdapter';
+import EventEmitter from '../utils/EventEmitter';
+import type Selector from '../types/Selector';
+import type Modifier from '../types/Modifier';
+import type DataAdapter from '../DataAdapter';
+import type { QueryOptions } from '../DataAdapter';
+import type StorageAdapter from '../types/StorageAdapter';
+import Cursor from './Cursor';
+import type { AsyncFindOptions, BaseItem, FindOptions, SyncFindOptions, Transform, TransformAll } from './types';
+export type { AnyFindOptions, AsyncFindOptions, BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions, SyncFindOptions, } from './types';
+export type { CursorOptions, QueryStateAccessor } from './Cursor';
+export type { ObserveCallbacks } from './Observer';
+export { default as createIndex } from '../createIndex';
+export interface CollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> {
+    /**
+     * @deprecated Use new constructor parameters instead.
+     */
+    name?: string;
+    /**
+     * @deprecated Use `DataAdapter` options instead.
+     */
+    persistence?: StorageAdapter<T, I>;
+    primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
+    reactivity?: ReactivityAdapter;
+    transform?: Transform<E, U>;
+    transformAll?: TransformAll<T, E>;
+    indices?: string[];
+    enableDebugMode?: boolean;
+    fieldTracking?: boolean;
+}
+interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
+    'added': (item: T) => void;
+    'changed': (item: T, modifier: Modifier<T>) => void;
+    'removed': (item: T) => void;
+    'observer.created': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
+    'observer.disposed': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
+    /**
+     * A query backing at least one live cursor failed and will not deliver
+     * results. The cursor keeps returning its neutral empty value, so without
+     * listening here a consumer cannot distinguish failure from "no data".
+     */
+    'query.error': <O extends QueryOptions<T>>(error: Error, selector?: Selector<T>, options?: O) => void;
+    'getItems': (selector: Selector<T> | undefined) => void;
+    'find': <Async extends boolean, O extends FindOptions<T, Async>>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => void;
+    'findOne': <O extends QueryOptions<T>>(selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
+    'insert': (item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
+    'updateOne': (selector: Selector<T>, modifier: Modifier<T>) => void;
+    'updateMany': (selector: Selector<T>, modifier: Modifier<T>) => void;
+    'replaceOne': (selector: Selector<T>, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
+    'removeOne': (selector: Selector<T>) => void;
+    'removeMany': (selector: Selector<T>) => void;
+    'validate': (item: T) => void;
+    '_debug.getItems': (callstack: string, selector: Selector<T> | undefined, measuredTime: number) => void;
+    '_debug.find': <Async extends boolean, O extends FindOptions<T, Async>>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => void;
+    '_debug.findOne': <Async extends boolean, O extends FindOptions<T, Async>>(callstack: string, selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
+    '_debug.insert': (callstack: string, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
+    '_debug.updateOne': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
+    '_debug.updateMany': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
+    '_debug.replaceOne': (callstack: string, selector: Selector<T>, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
+    '_debug.removeOne': (callstack: string, selector: Selector<T>) => void;
+    '_debug.removeMany': (callstack: string, selector: Selector<T>) => void;
+}
+/**
+ * Represents a collection of data items with support for in-memory operations,
+ * persistence, reactivity, and event-based notifications. The collection provides
+ * CRUD operations, observer patterns, and batch operations.
+ * @template T - The type of the items stored in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @template U - The transformed item type after applying transformations (default is T).
+ */
+export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends EventEmitter<CollectionEvents<T, E, U>> {
+    private static collections;
+    private static debugMode;
+    private static batchOperationInProgress;
+    private static fieldTracking;
+    private static onCreationCallbacks;
+    private static onDisposeCallbacks;
+    private static largeQueryWarningThreshold;
+    private static reportedLargeQueries;
+    static getCollections(): Collection<any, any, any, any>[];
+    /**
+     * Reports live queries whose result is larger than `rows`, once each, with
+     * the stack that registered them.
+     *
+     * A reactive query is re-evaluated whenever the data under it changes, and
+     * one registered from a long-lived place — a navigation bar, a provider
+     * near the root — keeps that cost for the lifetime of the application. There
+     * is otherwise nothing to see: the query works, and its price is only
+     * visible as an application that has grown slow. Finding one such query in a
+     * real app took a purpose-built profiler and the better part of a day.
+     * @param rows - Result size to report above, or `null` to switch the check off.
+     */
+    static reportLargeQueries(rows: number | null): void;
+    static onCreation(callback: (collection: Collection<any>) => void): void;
+    static onDispose(callback: (collection: Collection<any>) => void): void;
+    /**
+     * Enables debug mode for all collections.
+     */
+    static enableDebugMode: () => void;
+    /**
+     * Enables field tracking for all collections.
+     * @param enable - A boolean indicating whether to enable field tracking.
+     */
+    static setFieldTracking: (enable: boolean) => void;
+    /**
+     * Executes a batch operation, allowing multiple modifications to the collection
+     * while deferring index rebuilding until all operations in the batch are completed.
+     * This improves performance by avoiding repetitive index recalculations and
+     * provides atomicity for the batch of operations.
+     * Supports both synchronous and asynchronous callbacks.
+     *
+     * **Without a `collections` argument this affects every collection in the
+     * process, not only the ones being written to.** Each of them defers every
+     * live query's requery until the batch ends. That is what makes a batch
+     * cheap for a handful of writes belonging to one event, and what makes it
+     * dangerous around a loop whose length is data-dependent: while it is open
+     * nothing anywhere updates, and everything deferred is flushed at once when
+     * it closes. One application wrapped a sync of roughly 1,100 records this
+     * way and its screens stopped resolving their data for the whole drain.
+     *
+     * Pass the collections being written to whenever that scope is known — it is
+     * both cheaper and safer. `Collection.batch([logs, versions], () => …)`
+     * defers those two and leaves everything else live.
+     * @param collections - The collections to batch. Omit to batch all of them.
+     * @param callback - The batch operation to execute.
+     * @returns A promise if the callback returns a promise, otherwise `void`.
+     */
+    static batch<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
+    static batch<ReturnType>(callback: () => ReturnType): void;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => Promise<ReturnType>): Promise<void>;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => ReturnType): void;
+    readonly name: string;
+    private backend;
+    private options;
+    private isPullingSignal;
+    private isPushingSignal;
+    private readySignal;
+    private debugMode;
+    private batchOperationInProgress;
+    private isDisposed;
+    private postBatchCallbacks;
+    private fieldTracking;
+    private queryListenersMap;
+    private settledQueriesSet;
+    /**
+     * Initializes a new instance of the `Collection` class with optional configuration.
+     * Sets up memory, persistence, reactivity, and indices as specified in the options.
+     * @template T - The type of the items stored in the collection.
+     * @template I - The type of the unique identifier for the items.
+     * @template U - The transformed item type after applying transformations (default is T).
+     * @param name - The name of the collection.
+     * @param dataAdapter - The data adapter for creating the collection backend.
+     * @param options - Optional configuration for the collection.
+     * @param options.name - An optional name for the collection.
+     * @param options.memory - The in-memory adapter for storing items.
+     * @param options.reactivity - The reactivity adapter for observing changes in the collection.
+     * @param options.transform - A transformation function to apply to items when retrieving them.
+     * @param options.persistence - The persistence adapter for saving and loading items.
+     * @param options.indices - An array of index providers for optimized querying.
+     * @param options.enableDebugMode - A boolean to enable or disable debug mode.
+     * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
+     * @param options.transformAll - A function that will be able to solve the n+1 problem
+     */
+    constructor(options?: CollectionOptions<T, I, E, U>);
+    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, E, U>);
+    /**
+     * Reports a live query the first time its result is found to be larger than
+     * the configured threshold. Once per query, because it re-runs on every
+     * write and a warning per write would be its own performance problem.
+     * @param selector - The query's selector.
+     * @param options - The query's options.
+     * @param registrationStack - Where the query was registered, if captured.
+     */
+    private reportIfLargeQuery;
+    isBatchOperationInProgress(): boolean;
+    /**
+     * Checks whether the collection is currently performing a pull operation
+     * ⚡️ this function is reactive!
+     * (loading data from the persistence adapter).
+     * @returns A boolean indicating if the collection is in the process of pulling data.
+     */
+    isPulling(): boolean;
+    /**
+     * Checks whether the collection is currently performing a push operation
+     * ⚡️ this function is reactive!
+     * (saving data to the persistence adapter).
+     * @returns A boolean indicating if the collection is in the process of pushing data.
+     */
+    isPushing(): boolean;
+    /**
+     * Checks whether the collection is currently performing either a pull or push operation,
+     * ⚡️ this function is reactive!
+     * indicating that it is loading or saving data.
+     * @returns A boolean indicating if the collection is in the process of loading or saving data.
+     */
+    isLoading(): boolean;
+    /**
+     * Retrieves the current debug mode status of the collection.
+     * @returns A boolean indicating whether debug mode is enabled for the collection.
+     */
+    getDebugMode(): boolean;
+    /**
+     * Enables or disables debug mode for the collection.
+     * When debug mode is enabled, additional debugging information and events are emitted.
+     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
+     */
+    setDebugMode(enable: boolean): void;
+    /**
+     * Enables or disables field tracking for the collection.
+     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
+     */
+    setFieldTracking(enable: boolean): void;
+    /**
+     * Resolves when the persistence adapter finished initializing
+     * and the collection is ready to be used.
+     * @returns A promise that resolves when the collection is ready.
+     * @example
+     * ```ts
+     * const collection = new Collection({
+     *   persistence: // ...
+     * })
+     * await collection.isReady()
+     *
+     * collection.insert({ name: 'Item 1' })
+     */
+    ready(): Promise<void>;
+    /**
+     * Checks if the collection is ready.
+     * ⚡️ this function is reactive!
+     * @returns A boolean indicating whether the collection is ready.
+     */
+    isReady(): boolean;
+    private profile;
+    private executeInDebugMode;
+    private transform;
+    private transformAll;
+    private getItem;
+    private getItems;
+    private withPushState;
+    private queryListeners;
+    /**
+     * Disposes the collection, unregisters persistence adapters, clears memory, and
+     * cleans up all resources used by the collection.
+     * @returns A promise that resolves when the collection is disposed.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Finds multiple items in the collection based on a selector and optional options.
+     * Returns a cursor for reactive data queries.
+     * @param [selector] - The criteria to select items.
+     * @param [options] - Options for the find operation, such as limit and sort.
+     * @returns A cursor to fetch and observe the matching items.
+     */
+    find(selector?: Selector<T>, options?: SyncFindOptions<T>): Cursor<E, U, false>;
+    find(selector: Selector<T> | undefined, options: AsyncFindOptions<T>): Cursor<E, U, true>;
+    find(selector?: Selector<T>, options?: FindOptions<T, boolean>): Cursor<E, U, boolean>;
+    /**
+     * Finds a single item in the collection based on a selector and optional options.
+     * ⚡️ this function is reactive!
+     * Returns the found item or undefined if no item matches.
+     * @param selector - The criteria to select the item.
+     * @param [options] - Options for the find operation, such as projection.
+     * @returns The found item or `undefined`.
+     */
+    findOne(selector: Selector<T>, options?: Omit<SyncFindOptions<T>, 'limit'>): U | undefined;
+    findOne(selector: Selector<T>, options: Omit<AsyncFindOptions<T>, 'limit'>): Promise<U | undefined>;
+    findOne(selector: Selector<T>, options?: Omit<FindOptions<T, boolean>, 'limit'>): Promise<U | undefined> | U | undefined;
+    /**
+     * Performs a batch operation, deferring index rebuilds and allowing multiple
+     * modifications to be made atomically. Executes any post-batch callbacks afterwards.
+     * @param callback - The batch operation to execute.
+     * @returns A promise if the callback returns a promise, otherwise void.
+     */
+    batch<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
+    batch<ReturnType>(callback: () => ReturnType): void;
+    onPostBatch(callback: () => void): void;
+    /**
+     * Inserts a single item into the collection. Generates a unique ID if not provided.
+     * @param item - The item to insert.
+     * @returns The ID of the inserted item.
+     * @throws {Error} If the collection is disposed or the item has an invalid ID.
+     */
+    insert(item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<I>;
+    /**
+     * Inserts multiple items into the collection. Generates unique IDs for items if not provided.
+     * @param items - The items to insert.
+     * @returns An array of IDs of the inserted items.
+     * @throws {Error} If the collection is disposed or the items are invalid.
+     */
+    insertMany(items: Array<Omit<T, 'id'> & Partial<Pick<T, 'id'>>>): Promise<I[]>;
+    /**
+     * Updates a single item in the collection that matches the given selector.
+     * @param selector - The criteria to select the item to update.
+     * @param modifier - The modifications to apply to the item.
+     * @param [options] - Optional settings for the update operation.
+     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
+     * @returns The number of items updated (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    updateOne(selector: Selector<T>, modifier: Modifier<T>, options?: {
+        upsert?: boolean;
+    }): Promise<number>;
+    /**
+     * Updates multiple items in the collection that match the given selector.
+     * @param selector - The criteria to select the items to update.
+     * @param modifier - The modifications to apply to the items.
+     * @param [options] - Optional settings for the update operation.
+     * @param [options.upsert] - If `true`, creates new items if no items match the selector.
+     * @returns The number of items updated.
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    updateMany(selector: Selector<T>, modifier: Modifier<T>, options?: {
+        upsert?: boolean;
+    }): Promise<number>;
+    /**
+     * Replaces a single item in the collection that matches the given selector.
+     * @param selector - The criteria to select the item to replace.
+     * @param replacement - The item to replace the selected item with.
+     * @param [options] - Optional settings for the replace operation.
+     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
+     * @returns The number of items replaced (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>, options?: {
+        upsert?: boolean;
+    }): Promise<number>;
+    /**
+     * Removes a single item from the collection that matches the given selector.
+     * @param selector - The criteria to select the item to remove.
+     * @returns The number of items removed (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    removeOne(selector: Selector<T>): Promise<number>;
+    /**
+     * Removes multiple items from the collection that match the given selector.
+     * @param selector - The criteria to select the items to remove.
+     * @returns The number of items removed.
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    removeMany(selector: Selector<T>): Promise<number>;
+}