@oimdb/core 1.3.1 → 1.4.0

package/dist/index.d.ts

@@ -10,6 +10,7 @@ declare abstract class OIMCollectionStore<TEntity extends object, TPk extends TO
     abstract getAllPks(): TPk[];
     abstract countAll(): number;
     abstract clear(): void;
+    abstract destroy(): void;
 }
 
 declare abstract class OIMIndexStoreSetBased<TKey extends TOIMPk, TPk extends TOIMPk> {
@@ -41,8 +42,13 @@ type TOIMEventHandler<T> = (payload: T) => void;
 declare class OIMEventEmitter<T extends Record<string, unknown>> {
     private buckets;
     private getOrCreateBucket;
+    /**
+     * Compacts the handlers array by removing null entries (tombstones) left by handler removal.
+     * Rebuilds the indexByHandler map with updated indices and resets the tombstone count.
+     * This reduces array fragmentation and improves iteration performance.
+     */
     private compactBucket;
-    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
+    on<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): () => void;
     emit<K extends keyof T>(event: K, payload: T[K]): void;
     off<K extends keyof T>(event: K, handler: TOIMEventHandler<T[K]>): void;
     offAll<K extends keyof T>(event?: K): void;
@@ -262,6 +268,7 @@ declare class OIMDBSettings {
      * This constant is exported so users can create their own indexes and pass them to coalescers.
      */
     static readonly UPDATED_KEYS_INDEX_KEY: "__updatedKeys__";
+    static readonly FLUSHING_KEYS_INDEX_KEY: "__flushingKeys__";
 }
 
 /**
@@ -276,16 +283,20 @@ declare abstract class OIMUpdateEventCoalescer<TKey extends TOIMPk> {
         2: void;
     }>;
     protected readonly updatedKeysIndex: OIMIndexManualSetBased<typeof OIMDBSettings.UPDATED_KEYS_INDEX_KEY, TKey>;
+    protected readonly flushingUpdatedKeysIndex: OIMIndexManualSetBased<typeof OIMDBSettings.FLUSHING_KEYS_INDEX_KEY, TKey>;
     private hasEmittedChanges;
-    constructor(index?: OIMIndexManualSetBased<typeof OIMDBSettings.UPDATED_KEYS_INDEX_KEY, TKey>);
+    constructor(index?: OIMIndexManualSetBased<typeof OIMDBSettings.UPDATED_KEYS_INDEX_KEY, TKey>, flushingIndex?: OIMIndexManualSetBased<typeof OIMDBSettings.FLUSHING_KEYS_INDEX_KEY, TKey>);
     /**
      * Get the set of keys that have been updated since last clear
      */
     getUpdatedKeys(): Set<TKey>;
+    getFlushingUpdatedKeys(): Set<TKey>;
+    markUpdatedKeysAsFlushing(): void;
     /**
      * Clear all updated keys and reset the changed state
      */
     clearUpdatedKeys(): void;
+    clearFlushingUpdatedKeys(): void;
     /**
      * Add keys to the updated set and emit HAS_CHANGES event if needed
      */
@@ -321,6 +332,8 @@ declare class OIMEventQueue {
     protected queue: (() => void)[];
     protected readonly scheduler?: OIMEventQueueScheduler;
     protected flushBound?: () => void;
+    protected isFlushing: boolean;
+    protected pendingSchedule: boolean;
     constructor(options?: TOIMEventQueueOptions);
     /**
      * Add a function to the queue. If scheduler is configured and autoSchedule is enabled,
@@ -362,11 +375,23 @@ type TOIMUpdateEventEmitterOptions<TKey extends TOIMPk> = {
  * Optimized for performance with adaptive algorithms and memory management.
  */
 declare class OIMUpdateEventEmitter<TKey extends TOIMPk> {
+    protected keyHandlersBeforeFlush: Map<TKey, Set<TOIMEventHandler<void>>>;
     protected keyHandlers: Map<TKey, Set<TOIMEventHandler<void>>>;
     protected coalescer: OIMUpdateEventCoalescer<TKey>;
     protected queue: OIMEventQueue;
+    private isDestroyed;
+    private isDispatching;
+    private isInPrePhase;
+    private hasPendingDuringPrePhase;
+    private isFlushEnqueued;
     constructor(opts: TOIMUpdateEventEmitterOptions<TKey>);
     protected handleHasChanges: () => void;
+    protected readonly onFlush: () => void;
+    /**
+     * Helps to run computed values etc.
+     */
+    protected runPrePhaseDrain(makeHandlerSnapshot: (handlers: Set<TOIMEventHandler<void>>) => TOIMEventHandler<void>[]): Set<TKey>;
+    protected runHandlersPhase(allKeysForNormalPhase: ReadonlySet<TKey>, makeHandlerSnapshot: (handlers: Set<TOIMEventHandler<void>>) => TOIMEventHandler<void>[]): void;
     destroy(): void;
     /**
      * Get performance metrics for monitoring and debugging
@@ -385,9 +410,13 @@ declare class OIMUpdateEventEmitter<TKey extends TOIMPk> {
      * Get the number of handlers for a specific key
      */
     getHandlerCount(key: TKey): number;
+    subscribeOnKeyBeforeFlush(key: TKey, handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKeyBeforeFlush(key: TKey, handler: TOIMEventHandler<void>): void;
     subscribeOnKey(key: TKey, handler: TOIMEventHandler<void>): () => void;
     unsubscribeFromKey(key: TKey, handler: TOIMEventHandler<void>): void;
     subscribeOnKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    subscribeOnKeysBeforeFlush(keys: readonly TKey[], handler: TOIMEventHandler<void>): () => void;
+    unsubscribeFromKeysBeforeFlush(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
     unsubscribeFromKeys(keys: readonly TKey[], handler: TOIMEventHandler<void>): void;
 }
 
@@ -461,6 +490,20 @@ declare abstract class OIMReactiveIndexArrayBased<TKey extends TOIMPk, TPk exten
     destroy(): void;
 }
 
+declare abstract class OIMObjectStore<TKey extends string | number | symbol, TValue> {
+    abstract setProperty(key: TKey, value: TValue): void;
+    abstract merge(draft: Partial<Record<TKey, TValue>>): void;
+    abstract delete(key: TKey): void;
+    abstract get(key: TKey): TValue | undefined;
+    abstract getAll(): Record<TKey, TValue>;
+    abstract clear(): void;
+    abstract count(): number;
+    abstract keys(): TKey[];
+    abstract values(): TValue[];
+    abstract entries(): [TKey, TValue][];
+    abstract destroy(): void;
+}
+
 type TOIMPkSelector<TEntity extends object, TPk extends TOIMPk> = (entity: TEntity) => TPk;
 
 type TOIMEntityUpdater<TEntity extends object> = (draft: Partial<TEntity>, prevEntity: TEntity) => TEntity;
@@ -499,6 +542,7 @@ declare class OIMCollection<TEntity extends object, TPk extends TOIMPk> {
     getAllPks(): TPk[];
     protected upsertOneWithoutNotifications(entity: TEntity | Partial<TEntity>): TPk;
     protected upsertOneWithoutNotificationsByPk(pk: TPk, entity: Partial<TEntity> | TEntity): void;
+    destroy(): void;
 }
 
 declare enum EOIMCollectionEventType {
@@ -525,6 +569,64 @@ declare class OIMReactiveCollection<TEntity extends object, TPk extends TOIMPk>
     readonly updateEventEmitter: OIMUpdateEventEmitter<TPk>;
     readonly coalescer: OIMUpdateEventCoalescerCollection<TPk>;
     constructor(queue: OIMEventQueue, opts?: TOIMCollectionOptions<TEntity, TPk>);
+    destroy(): void;
+}
+
+/**
+ * Payload type for update events that contain keys */
+type TOIMUpdatePayload<TKey> = {
+    keys: readonly TKey[];
+};
+
+type TOIMObjectOptions<TKey extends string, TValue> = {
+    store?: OIMObjectStore<TKey, TValue>;
+};
+
+/** It's like a store - but with event emitter */
+declare class OIMObject<TKey extends string, TValue> {
+    readonly emitter: OIMEventEmitter<{
+        0: TOIMUpdatePayload<TKey>;
+    }>;
+    protected readonly store: OIMObjectStore<TKey, TValue>;
+    constructor(opts?: TOIMObjectOptions<TKey, TValue>);
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
+}
+
+declare enum EOIMObjectEventType {
+    UPDATE = 0
+}
+
+/**
+ * Object-specific coalescer that tracks property key updates and emits consolidated change events.
+ * Takes an event emitter directly instead of the whole object to avoid circular dependencies.
+ */
+declare class OIMUpdateEventCoalescerObject<TKey extends string> extends OIMUpdateEventCoalescer<TKey> {
+    private readonly objectEmitter;
+    constructor(objectEmitter: OIMEventEmitter<{
+        [EOIMObjectEventType.UPDATE]: TOIMUpdatePayload<TKey>;
+    }>);
+    destroy(): void;
+    /**
+     * When the object is updated, we keep track of the updated keys.
+     */
+    private handleUpdate;
+}
+
+declare class OIMReactiveObject<TKey extends string, TValue> extends OIMObject<TKey, TValue> {
+    readonly updateEventEmitter: OIMUpdateEventEmitter<TKey>;
+    readonly coalescer: OIMUpdateEventCoalescerObject<TKey>;
+    constructor(queue: OIMEventQueue, opts?: TOIMObjectOptions<TKey, TValue>);
+    destroy(): void;
 }
 
 declare class OIMReactiveIndexManualSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMReactiveIndexSetBased<TKey, TPk, OIMIndexManualSetBased<TKey, TPk>> {
@@ -598,6 +700,44 @@ declare class OIMCollectionStoreMapDriven<TEntity extends object, TPk extends TO
     countAll(): number;
     clear(): void;
     getAllPks(): TPk[];
+    destroy(): void;
+}
+
+declare class OIMObjectStoreMapDriven<TKey extends TOIMPk, TValue> extends OIMObjectStore<TKey, TValue> {
+    protected readonly properties: Map<TKey, TValue>;
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
+}
+
+/**
+ * Record-driven store (plain object) for OIMObject.
+ *
+ * Note: object keys are strings at runtime, so this store is limited to string keys
+ * for type-safety and predictable semantics.
+ */
+declare class OIMObjectStoreRecordDriven<TKey extends string, TValue> extends OIMObjectStore<TKey, TValue> {
+    protected properties: Record<TKey, TValue>;
+    constructor(initial?: Partial<Record<TKey, TValue>>);
+    setProperty(key: TKey, value: TValue): void;
+    merge(draft: Partial<Record<TKey, TValue>>): void;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    getAll(): Record<TKey, TValue>;
+    clear(): void;
+    count(): number;
+    keys(): TKey[];
+    values(): TValue[];
+    entries(): [TKey, TValue][];
+    destroy(): void;
 }
 
 declare class OIMIndexStoreMapDrivenSetBased<TKey extends TOIMPk, TPk extends TOIMPk> extends OIMIndexStoreSetBased<TKey, TPk> {
@@ -680,6 +820,139 @@ declare class OIMPkSelectorFactory<TEntity extends object, TPk extends TOIMPk> {
     }, TPk>;
 }
 
+/**
+ * Manual coalescer: you mark keys as updated explicitly.
+ *
+ * Useful for wrappers that maintain their own "derived" state (e.g. change-sets, command streams)
+ * and want to reuse `OIMUpdateEventEmitter` batching/reentrancy semantics without piggybacking
+ * on a collection/index/object emitter payload.
+ */
+declare class OIMUpdateEventCoalescerManual<TKey extends TOIMPk> extends OIMUpdateEventCoalescer<TKey> {
+    markUpdatedKeys(keys: readonly TKey[]): void;
+    destroy(): void;
+}
+
+type TOIMFieldKey<TEntity extends object> = keyof TEntity & string;
+/**
+ * Wrapper around `OIMReactiveCollection` that tracks "changed fields" per entity PK.
+ *
+ * Important: to get field-level info, you must perform writes through this wrapper.
+ * If you mutate the underlying collection directly, this wrapper will not be able
+ * to infer which fields changed (core update payloads carry only PKs).
+ */
+declare class OIMCollectionChangedFieldsWrapper<TEntity extends object, TPk extends TOIMPk> {
+    readonly collection: OIMReactiveCollection<TEntity, TPk>;
+    private readonly selectPk;
+    /**
+     * Emits updates scoped by PK. Subscribe, then read state via `getChangedFieldsByPk(...)`
+     * or drain via `consumeChangedFieldsByPk(...)`.
+     */
+    readonly changedPksEventEmitter: OIMUpdateEventEmitter<TPk>;
+    /**
+     * Emits updates scoped by field name. Subscribe, then read state via
+     * `getChangedPksByField(...)` or drain via `consumeChangedPksByField(...)`.
+     */
+    readonly changedFieldsEventEmitter: OIMUpdateEventEmitter<TOIMFieldKey<TEntity>>;
+    private readonly changedFieldsByPk;
+    private readonly changedPksByField;
+    private readonly changedPksCoalescer;
+    private readonly changedFieldsCoalescer;
+    constructor(queue: OIMEventQueue, collection: OIMReactiveCollection<TEntity, TPk>, opts?: {
+        /**
+         * Optional PK selector for convenience APIs like `upsertOne(...)`.
+         * If not provided, only `upsertOneByPk(...)` should be used.
+         */
+        selectPk?: (entity: TEntity | Partial<TEntity>) => TPk;
+    });
+    upsertOneByPk(pk: TPk, patch: Partial<TEntity>): void;
+    upsertOne(entity: TEntity | Partial<TEntity>): void;
+    upsertMany(entities: (TEntity | Partial<TEntity>)[]): void;
+    getChangedFieldsByPk(pk: TPk): ReadonlySet<TOIMFieldKey<TEntity>>;
+    consumeChangedFieldsByPk(pk: TPk): Set<TOIMFieldKey<TEntity>>;
+    getChangedPksByField(field: TOIMFieldKey<TEntity>): ReadonlySet<TPk>;
+    consumeChangedPksByField(field: TOIMFieldKey<TEntity>): Set<TPk>;
+    clear(): void;
+    destroy(): void;
+    private trackPatch;
+}
+
+/**
+ * Manual ordered Array-based index.
+ *
+ * Unlike `OIMIndexManualArrayBased.addPks/removePks`, this class is explicitly ordered:
+ * - preserves order
+ * - allows O(1) append (`push`)
+ * - supports `move` and `removeAt` without computing diffs
+ *
+ * It emits UPDATE events per key on every successful mutation.
+ */
+declare class OIMIndexManualOrderedArrayBased<TKey extends TOIMPk, TItemKey extends TOIMPk> extends OIMIndexArrayBased<TKey, TItemKey> {
+    clear(key?: TKey): void;
+    push(key: TKey, itemKey: TItemKey): number;
+    insertAt(key: TKey, index: number, itemKey: TItemKey): void;
+    removeAt(key: TKey, index: number): TItemKey | undefined;
+    move(key: TKey, fromIndex: number, toIndex: number): TItemKey | undefined;
+    reset(key: TKey, itemKeys: readonly TItemKey[]): void;
+    private getOrCreateList;
+}
+
+type TOIMOrderedListCommand<TPk extends TOIMPk> = {
+    type: 'add';
+    key: TPk;
+    index: number;
+} | {
+    type: 'remove';
+    key: TPk;
+    index: number;
+} | {
+    type: 'move';
+    key: TPk;
+    fromIndex: number;
+    toIndex: number;
+} | {
+    type: 'reset';
+    keys: readonly TPk[];
+};
+
+/**
+ * Ordered-list wrapper that stores arrays per key and emits a per-key command stream.
+ *
+ * This is designed for imperative renderers: instead of diffing the full list on each update,
+ * you subscribe to `commandsEventEmitter` on a single list key and apply commands sequentially.
+ *
+ * Notes:
+ * - Commands are buffered per key and delivered batched per queue flush.
+ * - Order of commands is preserved.
+ * - A future optimizer can collapse the command buffer into `reset(...)` if needed.
+ */
+declare class OIMOrderedListIndexCommandStreamWrapper<TKey extends TOIMPk, TItemKey extends TOIMPk> {
+    readonly commandsEventEmitter: OIMUpdateEventEmitter<TKey>;
+    private readonly coalescer;
+    private readonly commandsByKey;
+    /** Underlying ordered index (source of truth for the list). */
+    readonly index: OIMIndexManualOrderedArrayBased<TKey, TItemKey>;
+    constructor(queue: OIMEventQueue, index?: OIMIndexManualOrderedArrayBased<TKey, TItemKey>);
+    getPksByKey(key: TKey): readonly TItemKey[];
+    hasKey(key: TKey): boolean;
+    getKeys(): readonly TKey[];
+    push(key: TKey, itemKey: TItemKey): void;
+    removeAt(key: TKey, index: number): void;
+    move(key: TKey, fromIndex: number, toIndex: number): void;
+    reset(key: TKey, keys: readonly TItemKey[]): void;
+    /**
+     * Read-only peek at buffered commands without clearing them.
+     */
+    getBufferedCommands(key: TKey): readonly TOIMOrderedListCommand<TItemKey>[];
+    /**
+     * Drain buffered commands for a key, preserving order.
+     * Intended usage: call inside a `commandsEventEmitter.subscribeOnKey(key, ...)` handler.
+     */
+    consumeCommands(key: TKey): TOIMOrderedListCommand<TItemKey>[];
+    clear(key?: TKey): void;
+    destroy(): void;
+    private appendCommand;
+}
+
 /**
  * Animation frame-based scheduler that executes flushes synchronized with the browser's repaint cycle.
  * Ideal for UI-related updates that need to be synchronized with rendering.
@@ -780,8 +1053,17 @@ declare class OIMEventQueueSchedulerFactory {
 /**
  * Event types for update coalescers */
 declare enum EOIMUpdateEventCoalescerEventType {
+    /**
+     * @description Emitted when there are any first changes to the updated keys
+     */
     HAS_CHANGES = 0,
+    /**
+     * @description Emitted before the flush of the updated keys
+     */
     BEFORE_FLUSH = 1,
+    /**
+     * @description Emitted after the flush of the updated keys
+     */
     AFTER_FLUSH = 2
 }
 
@@ -809,10 +1091,148 @@ type TOIMIndexPksUpdatePayload<TKey extends TOIMPk, TPk extends TOIMPk> = {
     pks: readonly TPk[];
 };
 
-/**
- * Payload type for update events that contain keys */
-type TOIMUpdatePayload<TKey> = {
+declare enum EOIMEffectPhase {
+    PRE = "pre",
+    HANDLERS = "handlers"
+}
+
+interface IOIMEffectDependency {
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+type TOIMComputedOptions<TValue> = {
+    compute: () => TValue;
+    deps?: readonly IOIMEffectDependency[];
+    compare?: (a: TValue, b: TValue) => boolean;
+};
+
+type TOIMComputedUpdatePayload<TKey extends TOIMPk> = {
     keys: readonly TKey[];
 };
 
-export { EOIMCollectionEventType, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMUpdateEventCoalescerEventType, type IOIMEventQueueSchedulerEvents, OIMCollection, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMDBSettings, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualSetBased, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMPkSelectorFactory, OIMRICollection, OIMReactiveCollection, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMUpdateEventCoalescer, OIMUpdateEventCoalescerCollection, OIMUpdateEventCoalescerIndex, OIMUpdateEventEmitter, type TOIMCollectionOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptions, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMPk, type TOIMPkSelector, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdateEventEmitterOptions, type TOIMUpdatePayload };
+declare enum EOIMComputedEventType {
+    UPDATE = "update"
+}
+
+declare class OIMUpdateEventCoalescerComputed<TKey extends TOIMPk> extends OIMUpdateEventCoalescer<TKey> {
+    private readonly computedEmitter;
+    constructor(computedEmitter: OIMEventEmitter<{
+        [EOIMComputedEventType.UPDATE]: TOIMComputedUpdatePayload<TKey>;
+    }>);
+    destroy(): void;
+    private handleUpdate;
+}
+
+type TOIMComputedKey$2 = 'value';
+declare class OIMComputed<TValue> {
+    readonly emitter: OIMEventEmitter<{
+        update: TOIMComputedUpdatePayload<TOIMComputedKey$2>;
+    }>;
+    readonly coalescer: OIMUpdateEventCoalescerComputed<TOIMComputedKey$2>;
+    readonly updateEventEmitter: OIMUpdateEventEmitter<TOIMComputedKey$2>;
+    private readonly queue;
+    private readonly compute;
+    private readonly compare;
+    private readonly deps;
+    private value;
+    private hasValue;
+    private isDirty;
+    private isInFlush;
+    private hasRecomputedInThisFlush;
+    private readonly effect;
+    private readonly handleQueueBeforeFlush;
+    private readonly handleQueueAfterFlush;
+    constructor(queue: OIMEventQueue, opts: TOIMComputedOptions<TValue>);
+    get(): TValue;
+    getIfReady(): TValue | undefined;
+    destroy(): void;
+    private recomputeAndEmitIfChanged;
+}
+
+type TOIMComputedKey$1 = 'value';
+interface IOIMComputedEventSource {
+    emitter: OIMEventEmitter<{
+        [EOIMComputedEventType.UPDATE]: TOIMComputedUpdatePayload<TOIMComputedKey$1>;
+    }>;
+}
+
+type TOIMEffectOptions = {
+    deps?: readonly IOIMEffectDependency[];
+    phase: EOIMEffectPhase;
+    onInvalidate?: () => void;
+    run: () => void;
+};
+
+declare class OIMEffect {
+    private readonly queue;
+    private readonly phase;
+    private readonly onInvalidate?;
+    private readonly run;
+    private readonly deps;
+    private unsubscribers;
+    private isDestroyed;
+    private isInFlush;
+    private hasRunInThisFlush;
+    private isScheduled;
+    private readonly handleQueueBeforeFlush;
+    private readonly handleQueueAfterFlush;
+    private readonly runTask;
+    constructor(queue: OIMEventQueue, opts: TOIMEffectOptions);
+    destroy(): void;
+    private invalidate;
+    private runOnce;
+}
+
+declare class OIMEffectDependencyKeyed<TKey extends TOIMPk> implements IOIMEffectDependency {
+    private readonly updateEventEmitter;
+    private readonly key;
+    private readonly keys;
+    constructor(updateEventEmitter: OIMUpdateEventEmitter<TKey>, keyOrKeys: TKey | readonly TKey[]);
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedObject<TKey extends string, TValue> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(object: OIMReactiveObject<TKey, TValue>, key: TKey);
+    constructor(object: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]);
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedCollection<TEntity extends object, TPk extends TOIMPk> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pk: TPk);
+    constructor(collection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]);
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+declare class OIMEffectDependencyKeyedIndex<TKey extends TOIMPk> implements IOIMEffectDependency {
+    private readonly dep;
+    constructor(index: {
+        updateEventEmitter: OIMUpdateEventEmitter<TKey>;
+    }, key: TKey);
+    constructor(index: {
+        updateEventEmitter: OIMUpdateEventEmitter<TKey>;
+    }, keys: readonly TKey[]);
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+type TOIMComputedKey = 'value';
+type TOIMComputedLike = {
+    emitter: OIMEventEmitter<{
+        update: TOIMComputedUpdatePayload<TOIMComputedKey>;
+    }>;
+    updateEventEmitter: OIMUpdateEventEmitter<TOIMComputedKey>;
+};
+/**
+ * Effect dependency on a computed.
+ *
+ * - PRE: subscribe directly to computed.emitter for immediate invalidation during pre-drain.
+ * - HANDLERS: subscribe via computed.updateEventEmitter (normal handlers) which is delivered through queue.
+ */
+declare class OIMEffectDependencyComputed implements IOIMEffectDependency {
+    private readonly computed;
+    constructor(computed: TOIMComputedLike);
+    subscribe(phase: EOIMEffectPhase, onInvalidate: () => void): () => void;
+}
+
+export { EOIMCollectionEventType, EOIMComputedEventType, EOIMEffectPhase, EOIMEventQueueEventType, EOIMEventQueueSchedulerEventType, EOIMIndexEventType, EOIMObjectEventType, EOIMUpdateEventCoalescerEventType, type IOIMComputedEventSource, type IOIMEffectDependency, type IOIMEventQueueSchedulerEvents, OIMCollection, OIMCollectionChangedFieldsWrapper, OIMCollectionStore, OIMCollectionStoreMapDriven, OIMComparatorFactory, OIMComputed, OIMDBSettings, OIMEffect, OIMEffectDependencyComputed, OIMEffectDependencyKeyed, OIMEffectDependencyKeyedCollection, OIMEffectDependencyKeyedIndex, OIMEffectDependencyKeyedObject, OIMEntityUpdaterFactory, OIMEventEmitter, OIMEventQueue, OIMEventQueueScheduler, OIMEventQueueSchedulerAnimationFrame, OIMEventQueueSchedulerFactory, OIMEventQueueSchedulerImmediate, OIMEventQueueSchedulerMicrotask, OIMEventQueueSchedulerTimeout, OIMIndexArrayBased, OIMIndexComparatorFactory, OIMIndexManualArrayBased, OIMIndexManualOrderedArrayBased, OIMIndexManualSetBased, OIMIndexSetBased, OIMIndexStoreArrayBased, OIMIndexStoreMapDrivenArrayBased, OIMIndexStoreMapDrivenSetBased, OIMIndexStoreSetBased, OIMMap2Keys, OIMObject, OIMObjectStore, OIMObjectStoreMapDriven, OIMObjectStoreRecordDriven, OIMOrderedListIndexCommandStreamWrapper, OIMPkSelectorFactory, OIMRICollection, OIMReactiveCollection, OIMReactiveIndexArrayBased, OIMReactiveIndexManualArrayBased, OIMReactiveIndexManualSetBased, OIMReactiveIndexSetBased, OIMReactiveObject, OIMUpdateEventCoalescer, OIMUpdateEventCoalescerCollection, OIMUpdateEventCoalescerComputed, OIMUpdateEventCoalescerIndex, OIMUpdateEventCoalescerManual, OIMUpdateEventCoalescerObject, OIMUpdateEventEmitter, type TOIMCollectionOptions, type TOIMCollectionUpdatePayload, type TOIMComparator, type TOIMComputedOptions, type TOIMComputedUpdatePayload, type TOIMEffectOptions, type TOIMEntityUpdater, type TOIMEventHandler, type TOIMEventQueueOptions, type TOIMIndexComparator, type TOIMIndexKey, type TOIMIndexOptions, type TOIMIndexOptionsArrayBased, type TOIMIndexOptionsSetBased, type TOIMIndexPksUpdatePayload, type TOIMIndexUpdatePayload, type TOIMObjectOptions, type TOIMOrderedListCommand, type TOIMPk, type TOIMPkSelector, type TOIMSchedulerOptions, type TOIMSchedulerType, type TOIMUpdateEventEmitterOptions, type TOIMUpdatePayload };