@tanstack/db 0.3.2 → 0.4.1

package/dist/{esm/collection.d.ts → cjs/collection/index.d.cts}

@@ -1,19 +1,13 @@
-import { SortedMap } from './SortedMap.js';
-import { BTreeIndex } from './indexes/btree-index.js';
-import { IndexProxy } from './indexes/lazy-index.js';
-import { AllCollectionEvents, CollectionEventHandler } from './collection-events.js';
-import { Transaction } from './transactions.js';
+import { CollectionStateManager } from './state.cjs';
+import { CollectionSubscription } from './subscription.cjs';
+import { AllCollectionEvents, CollectionEventHandler } from './events.js';
+import { BaseIndex, IndexResolver } from '../indexes/base-index.js';
+import { IndexOptions } from '../indexes/index-options.js';
+import { ChangeMessage, CollectionConfig, CollectionStatus, CurrentStateAsChangesOptions, Fn, InferSchemaInput, InferSchemaOutput, InsertConfig, OperationConfig, SubscribeChangesOptions, Transaction as TransactionType, UtilsRecord, WritableDeep } from '../types.cjs';
+import { SingleRowRefProxy } from '../query/builder/ref-proxy.cjs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { SingleRowRefProxy } from './query/builder/ref-proxy.js';
-import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, CurrentStateAsChangesOptions, Fn, InferSchemaInput, InferSchemaOutput, InsertConfig, OperationConfig, OptimisticChangeMessage, SubscribeChangesOptions, Transaction as TransactionType, UtilsRecord, WritableDeep } from './types.js';
-import { IndexOptions } from './indexes/index-options.js';
-import { BaseIndex, IndexResolver } from './indexes/base-index.js';
-interface PendingSyncedTransaction<T extends object = Record<string, unknown>> {
-    committed: boolean;
-    operations: Array<OptimisticChangeMessage<T>>;
-    truncate?: boolean;
-    deletedKeys: Set<string | number>;
-}
+import { BTreeIndex } from '../indexes/btree-index.js';
+import { IndexProxy } from '../indexes/lazy-index.js';
 /**
  * Enhanced Collection interface that includes both data type T and utilities TUtils
  * @template T - The type of items in the collection
@@ -103,36 +97,31 @@ export declare function createCollection<T extends object, TKey extends string |
     utils?: TUtils;
 }): Collection<T, TKey, TUtils, never, T>;
 export declare class CollectionImpl<TOutput extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInput extends object = TOutput> {
+    id: string;
     config: CollectionConfig<TOutput, TKey, TSchema>;
-    transactions: SortedMap<string, Transaction<any>>;
-    pendingSyncedTransactions: Array<PendingSyncedTransaction<TOutput>>;
-    syncedData: Map<TKey, TOutput> | SortedMap<TKey, TOutput>;
-    syncedMetadata: Map<TKey, unknown>;
-    optimisticUpserts: Map<TKey, TOutput>;
-    optimisticDeletes: Set<TKey>;
-    private _size;
-    private lazyIndexes;
-    private resolvedIndexes;
-    private isIndexesResolved;
-    private indexCounter;
-    private changeListeners;
-    private changeKeyListeners;
     utils: Record<string, Fn>;
-    private syncedKeys;
-    private preSyncVisibleState;
-    private recentlySyncedKeys;
-    private hasReceivedFirstCommit;
-    private isCommittingSyncTransactions;
-    private onFirstReadyCallbacks;
-    private hasBeenReady;
-    private batchedEvents;
-    private shouldBatchEvents;
-    private _status;
-    private activeSubscribersCount;
-    private gcTimeoutId;
-    private preloadPromise;
-    private syncCleanupFn;
-    private events;
+    private _events;
+    private _changes;
+    private _lifecycle;
+    private _sync;
+    private _indexes;
+    private _mutations;
+    _state: CollectionStateManager<TOutput, TKey, TSchema, TInput>;
+    /**
+     * Creates a new Collection instance
+     *
+     * @param config - Configuration object for the collection
+     * @throws Error if sync config is missing
+     */
+    constructor(config: CollectionConfig<TOutput, TKey, TSchema>);
+    /**
+     * Gets the current status of the collection
+     */
+    get status(): CollectionStatus;
+    /**
+     * Get the number of subscribers to the collection
+     */
+    get subscriberCount(): number;
     /**
      * Register a callback to be executed when the collection first becomes ready
      * Useful for preloading collections
@@ -157,107 +146,16 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      * }
      */
     isReady(): boolean;
-    /**
-     * Mark the collection as ready for use
-     * This is called by sync implementations to explicitly signal that the collection is ready,
-     * providing a more intuitive alternative to using commits for readiness signaling
-     * @private - Should only be called by sync implementations
-     */
-    private markReady;
-    id: string;
-    /**
-     * Gets the current status of the collection
-     */
-    get status(): CollectionStatus;
-    /**
-     * Get the number of subscribers to the collection
-     */
-    get subscriberCount(): number;
-    /**
-     * Validates that the collection is in a usable state for data operations
-     * @private
-     */
-    private validateCollectionUsable;
-    /**
-     * Validates state transitions to prevent invalid status changes
-     * @private
-     */
-    private validateStatusTransition;
-    /**
-     * Safely update the collection status with validation
-     * @private
-     */
-    private setStatus;
-    /**
-     * Creates a new Collection instance
-     *
-     * @param config - Configuration object for the collection
-     * @throws Error if sync config is missing
-     */
-    constructor(config: CollectionConfig<TOutput, TKey, TSchema>);
     /**
      * Start sync immediately - internal method for compiled queries
      * This bypasses lazy loading for special cases like live query results
      */
     startSyncImmediate(): void;
-    /**
-     * Start the sync process for this collection
-     * This is called when the collection is first accessed or preloaded
-     */
-    private startSync;
     /**
      * Preload the collection data by starting sync if not already started
      * Multiple concurrent calls will share the same promise
      */
     preload(): Promise<void>;
-    /**
-     * Clean up the collection by stopping sync and clearing data
-     * This can be called manually or automatically by garbage collection
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Start the garbage collection timer
-     * Called when the collection becomes inactive (no subscribers)
-     */
-    private startGCTimer;
-    /**
-     * Cancel the garbage collection timer
-     * Called when the collection becomes active again
-     */
-    private cancelGCTimer;
-    /**
-     * Increment the active subscribers count and start sync if needed
-     */
-    private addSubscriber;
-    /**
-     * Decrement the active subscribers count and start GC timer if needed
-     */
-    private removeSubscriber;
-    /**
-     * Recompute optimistic state from active transactions
-     */
-    private recomputeOptimisticState;
-    /**
-     * Calculate the current size based on synced data and optimistic changes
-     */
-    private calculateSize;
-    /**
-     * Collect events for optimistic changes
-     */
-    private collectOptimisticChanges;
-    /**
-     * Get the previous value for a key given previous optimistic state
-     */
-    private getPreviousValue;
-    /**
-     * Emit an empty ready event to notify subscribers that the collection is ready
-     * This bypasses the normal empty array check in emitEvents
-     */
-    private emitEmptyReadyEvent;
-    /**
-     * Emit events either immediately or batch them for later emission
-     */
-    private emitEvents;
     /**
      * Get the current value for a key (virtual derived state)
      */
@@ -294,19 +192,7 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      * Create a new array with the results of calling a function for each entry in the collection
      */
     map<U>(callbackfn: (value: TOutput, key: TKey, index: number) => U): Array<U>;
-    /**
-     * Attempts to commit pending synced transactions if there are no active transactions
-     * This method processes operations from pending transactions and applies them to the synced data
-     */
-    commitPendingTransactions: () => void;
-    /**
-     * Schedule cleanup of a transaction when it completes
-     * @private
-     */
-    private scheduleTransactionCleanup;
-    private ensureStandardSchema;
     getKeyFromItem(item: TOutput): TKey;
-    generateGlobalKey(key: any, item: any): string;
     /**
      * Creates an index on a collection for faster queries.
      * Indexes significantly improve query performance by allowing constant time lookups
@@ -338,25 +224,13 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      * })
      */
     createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(indexCallback: (row: SingleRowRefProxy<TOutput>) => any, config?: IndexOptions<TResolver>): IndexProxy<TKey>;
-    /**
-     * Resolve all lazy indexes (called when collection first syncs)
-     * @private
-     */
-    private resolveAllIndexes;
-    /**
-     * Resolve a single index immediately
-     * @private
-     */
-    private resolveSingleIndex;
     /**
      * Get resolved indexes for query optimization
      */
     get indexes(): Map<number, BaseIndex<TKey>>;
     /**
-     * Updates all indexes when the collection changes
-     * @private
+     * Validates the data against the schema
      */
-    private updateIndexes;
     validateData(data: unknown, type: `insert` | `update`, key?: TKey): TOutput | never;
     /**
      * Inserts one or more items into the collection
@@ -394,7 +268,7 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      *   console.log('Insert failed:', error)
      * }
      */
-    insert: (data: TInput | Array<TInput>, config?: InsertConfig) => Transaction<Record<string, unknown>> | Transaction<TOutput>;
+    insert: (data: TInput | Array<TInput>, config?: InsertConfig) => TransactionType<Record<string, unknown>> | TransactionType<TOutput>;
     /**
      * Updates one or more items in the collection using a callback function
      * @param keys - Single key or array of keys to update
@@ -524,7 +398,7 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      *   whereExpression: eq(row.status, 'active')
      * })
      */
-    currentStateAsChanges(options?: CurrentStateAsChangesOptions<TOutput>): Array<ChangeMessage<TOutput>>;
+    currentStateAsChanges(options?: CurrentStateAsChangesOptions): Array<ChangeMessage<TOutput>> | void;
     /**
      * Subscribe to changes in the collection
      * @param callback - Function called when items change
@@ -532,23 +406,23 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      * @returns Unsubscribe function - Call this to stop listening for changes
      * @example
      * // Basic subscription
-     * const unsubscribe = collection.subscribeChanges((changes) => {
+     * const subscription = collection.subscribeChanges((changes) => {
      *   changes.forEach(change => {
      *     console.log(`${change.type}: ${change.key}`, change.value)
      *   })
      * })
      *
-     * // Later: unsubscribe()
+     * // Later: subscription.unsubscribe()
      *
      * @example
      * // Include current state immediately
-     * const unsubscribe = collection.subscribeChanges((changes) => {
+     * const subscription = collection.subscribeChanges((changes) => {
      *   updateUI(changes)
      * }, { includeInitialState: true })
      *
      * @example
      * // Subscribe only to changes matching a condition
-     * const unsubscribe = collection.subscribeChanges((changes) => {
+     * const subscription = collection.subscribeChanges((changes) => {
      *   updateUI(changes)
      * }, {
      *   includeInitialState: true,
@@ -557,30 +431,14 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      *
      * @example
      * // Subscribe using a pre-compiled expression
-     * const unsubscribe = collection.subscribeChanges((changes) => {
+     * const subscription = collection.subscribeChanges((changes) => {
      *   updateUI(changes)
      * }, {
      *   includeInitialState: true,
      *   whereExpression: eq(row.status, 'active')
      * })
      */
-    subscribeChanges(callback: (changes: Array<ChangeMessage<TOutput>>) => void, options?: SubscribeChangesOptions<TOutput>): () => void;
-    /**
-     * Subscribe to changes for a specific key
-     */
-    subscribeChangesKey(key: TKey, listener: ChangeListener<TOutput, TKey>, { includeInitialState }?: {
-        includeInitialState?: boolean;
-    }): () => void;
-    /**
-     * Capture visible state for keys that will be affected by pending sync operations
-     * This must be called BEFORE onTransactionStateChange clears optimistic state
-     */
-    private capturePreSyncVisibleState;
-    /**
-     * Trigger a recomputation when transactions change
-     * This method should be called by the Transaction class when state changes
-     */
-    onTransactionStateChange(): void;
+    subscribeChanges(callback: (changes: Array<ChangeMessage<TOutput>>) => void, options?: SubscribeChangesOptions): CollectionSubscription;
     /**
      * Subscribe to a collection event
      */
@@ -597,5 +455,9 @@ export declare class CollectionImpl<TOutput extends object = Record<string, unkn
      * Wait for a collection event
      */
     waitFor<T extends keyof AllCollectionEvents>(event: T, timeout?: number): Promise<AllCollectionEvents[T]>;
+    /**
+     * Clean up the collection by stopping sync and clearing data
+     * This can be called manually or automatically by garbage collection
+     */
+    cleanup(): Promise<void>;
 }
-export {};

package/dist/cjs/collection/indexes.cjs

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lazyIndex = require("../indexes/lazy-index.cjs");
+const refProxy = require("../query/builder/ref-proxy.cjs");
+const btreeIndex = require("../indexes/btree-index.cjs");
+class CollectionIndexesManager {
+  constructor() {
+    this.lazyIndexes = /* @__PURE__ */ new Map();
+    this.resolvedIndexes = /* @__PURE__ */ new Map();
+    this.isIndexesResolved = false;
+    this.indexCounter = 0;
+  }
+  setDeps(deps) {
+    this.state = deps.state;
+    this.lifecycle = deps.lifecycle;
+  }
+  /**
+   * Creates an index on a collection for faster queries.
+   */
+  createIndex(indexCallback, config = {}) {
+    this.lifecycle.validateCollectionUsable(`createIndex`);
+    const indexId = ++this.indexCounter;
+    const singleRowRefProxy = refProxy.createSingleRowRefProxy();
+    const indexExpression = indexCallback(singleRowRefProxy);
+    const expression = refProxy.toExpression(indexExpression);
+    const resolver = config.indexType ?? btreeIndex.BTreeIndex;
+    const lazyIndex$1 = new lazyIndex.LazyIndexWrapper(
+      indexId,
+      expression,
+      config.name,
+      resolver,
+      config.options,
+      this.state.entries()
+    );
+    this.lazyIndexes.set(indexId, lazyIndex$1);
+    if (resolver === btreeIndex.BTreeIndex) {
+      try {
+        const resolvedIndex = lazyIndex$1.getResolved();
+        this.resolvedIndexes.set(indexId, resolvedIndex);
+      } catch (error) {
+        console.warn(`Failed to resolve BTreeIndex:`, error);
+      }
+    } else if (typeof resolver === `function` && resolver.prototype) {
+      try {
+        const resolvedIndex = lazyIndex$1.getResolved();
+        this.resolvedIndexes.set(indexId, resolvedIndex);
+      } catch {
+        this.resolveSingleIndex(indexId, lazyIndex$1).catch((error) => {
+          console.warn(`Failed to resolve single index:`, error);
+        });
+      }
+    } else if (this.isIndexesResolved) {
+      this.resolveSingleIndex(indexId, lazyIndex$1).catch((error) => {
+        console.warn(`Failed to resolve single index:`, error);
+      });
+    }
+    return new lazyIndex.IndexProxy(indexId, lazyIndex$1);
+  }
+  /**
+   * Resolve all lazy indexes (called when collection first syncs)
+   */
+  async resolveAllIndexes() {
+    if (this.isIndexesResolved) return;
+    const resolutionPromises = Array.from(this.lazyIndexes.entries()).map(
+      async ([indexId, lazyIndex2]) => {
+        const resolvedIndex = await lazyIndex2.resolve();
+        resolvedIndex.build(this.state.entries());
+        this.resolvedIndexes.set(indexId, resolvedIndex);
+        return { indexId, resolvedIndex };
+      }
+    );
+    await Promise.all(resolutionPromises);
+    this.isIndexesResolved = true;
+  }
+  /**
+   * Resolve a single index immediately
+   */
+  async resolveSingleIndex(indexId, lazyIndex2) {
+    const resolvedIndex = await lazyIndex2.resolve();
+    resolvedIndex.build(this.state.entries());
+    this.resolvedIndexes.set(indexId, resolvedIndex);
+    return resolvedIndex;
+  }
+  /**
+   * Get resolved indexes for query optimization
+   */
+  get indexes() {
+    return this.resolvedIndexes;
+  }
+  /**
+   * Updates all indexes when the collection changes
+   */
+  updateIndexes(changes) {
+    for (const index of this.resolvedIndexes.values()) {
+      for (const change of changes) {
+        switch (change.type) {
+          case `insert`:
+            index.add(change.key, change.value);
+            break;
+          case `update`:
+            if (change.previousValue) {
+              index.update(change.key, change.previousValue, change.value);
+            } else {
+              index.add(change.key, change.value);
+            }
+            break;
+          case `delete`:
+            index.remove(change.key, change.value);
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * Clean up the collection by stopping sync and clearing data
+   * This can be called manually or automatically by garbage collection
+   */
+  cleanup() {
+    this.lazyIndexes.clear();
+    this.resolvedIndexes.clear();
+  }
+}
+exports.CollectionIndexesManager = CollectionIndexesManager;
+//# sourceMappingURL=indexes.cjs.map

package/dist/cjs/collection/indexes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.cjs","sources":["../../../src/collection/indexes.ts"],"sourcesContent":["import { IndexProxy, LazyIndexWrapper } from \"../indexes/lazy-index\"\nimport {\n  createSingleRowRefProxy,\n  toExpression,\n} from \"../query/builder/ref-proxy\"\nimport { BTreeIndex } from \"../indexes/btree-index\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport type { BaseIndex, IndexResolver } from \"../indexes/base-index\"\nimport type { ChangeMessage } from \"../types\"\nimport type { IndexOptions } from \"../indexes/index-options\"\nimport type { SingleRowRefProxy } from \"../query/builder/ref-proxy\"\nimport type { CollectionLifecycleManager } from \"./lifecycle\"\nimport type { CollectionStateManager } from \"./state\"\n\nexport class CollectionIndexesManager<\n  TOutput extends object = Record<string, unknown>,\n  TKey extends string | number = string | number,\n  TSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TInput extends object = TOutput,\n> {\n  private lifecycle!: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>\n  private state!: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n\n  public lazyIndexes = new Map<number, LazyIndexWrapper<TKey>>()\n  public resolvedIndexes = new Map<number, BaseIndex<TKey>>()\n  public isIndexesResolved = false\n  public indexCounter = 0\n\n  constructor() {}\n\n  setDeps(deps: {\n    state: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n    lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>\n  }) {\n    this.state = deps.state\n    this.lifecycle = deps.lifecycle\n  }\n\n  /**\n   * Creates an index on a collection for faster queries.\n   */\n  public createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(\n    indexCallback: (row: SingleRowRefProxy<TOutput>) => any,\n    config: IndexOptions<TResolver> = {}\n  ): IndexProxy<TKey> {\n    this.lifecycle.validateCollectionUsable(`createIndex`)\n\n    const indexId = ++this.indexCounter\n    const singleRowRefProxy = createSingleRowRefProxy<TOutput>()\n    const indexExpression = indexCallback(singleRowRefProxy)\n    const expression = toExpression(indexExpression)\n\n    // Default to BTreeIndex if no type specified\n    const resolver = config.indexType ?? (BTreeIndex as unknown as TResolver)\n\n    // Create lazy wrapper\n    const lazyIndex = new LazyIndexWrapper<TKey>(\n      indexId,\n      expression,\n      config.name,\n      resolver,\n      config.options,\n      this.state.entries()\n    )\n\n    this.lazyIndexes.set(indexId, lazyIndex)\n\n    // For BTreeIndex, resolve immediately and synchronously\n    if ((resolver as unknown) === BTreeIndex) {\n      try {\n        const resolvedIndex = lazyIndex.getResolved()\n        this.resolvedIndexes.set(indexId, resolvedIndex)\n      } catch (error) {\n        console.warn(`Failed to resolve BTreeIndex:`, error)\n      }\n    } else if (typeof resolver === `function` && resolver.prototype) {\n      // Other synchronous constructors - resolve immediately\n      try {\n        const resolvedIndex = lazyIndex.getResolved()\n        this.resolvedIndexes.set(indexId, resolvedIndex)\n      } catch {\n        // Fallback to async resolution\n        this.resolveSingleIndex(indexId, lazyIndex).catch((error) => {\n          console.warn(`Failed to resolve single index:`, error)\n        })\n      }\n    } else if (this.isIndexesResolved) {\n      // Async loader but indexes are already resolved - resolve this one\n      this.resolveSingleIndex(indexId, lazyIndex).catch((error) => {\n        console.warn(`Failed to resolve single index:`, error)\n      })\n    }\n\n    return new IndexProxy(indexId, lazyIndex)\n  }\n\n  /**\n   * Resolve all lazy indexes (called when collection first syncs)\n   */\n  public async resolveAllIndexes(): Promise<void> {\n    if (this.isIndexesResolved) return\n\n    const resolutionPromises = Array.from(this.lazyIndexes.entries()).map(\n      async ([indexId, lazyIndex]) => {\n        const resolvedIndex = await lazyIndex.resolve()\n\n        // Build index with current data\n        resolvedIndex.build(this.state.entries())\n\n        this.resolvedIndexes.set(indexId, resolvedIndex)\n        return { indexId, resolvedIndex }\n      }\n    )\n\n    await Promise.all(resolutionPromises)\n    this.isIndexesResolved = true\n  }\n\n  /**\n   * Resolve a single index immediately\n   */\n  private async resolveSingleIndex(\n    indexId: number,\n    lazyIndex: LazyIndexWrapper<TKey>\n  ): Promise<BaseIndex<TKey>> {\n    const resolvedIndex = await lazyIndex.resolve()\n    resolvedIndex.build(this.state.entries())\n    this.resolvedIndexes.set(indexId, resolvedIndex)\n    return resolvedIndex\n  }\n\n  /**\n   * Get resolved indexes for query optimization\n   */\n  get indexes(): Map<number, BaseIndex<TKey>> {\n    return this.resolvedIndexes\n  }\n\n  /**\n   * Updates all indexes when the collection changes\n   */\n  public updateIndexes(changes: Array<ChangeMessage<TOutput, TKey>>): void {\n    for (const index of this.resolvedIndexes.values()) {\n      for (const change of changes) {\n        switch (change.type) {\n          case `insert`:\n            index.add(change.key, change.value)\n            break\n          case `update`:\n            if (change.previousValue) {\n              index.update(change.key, change.previousValue, change.value)\n            } else {\n              index.add(change.key, change.value)\n            }\n            break\n          case `delete`:\n            index.remove(change.key, change.value)\n            break\n        }\n      }\n    }\n  }\n\n  /**\n   * Clean up the collection by stopping sync and clearing data\n   * This can be called manually or automatically by garbage collection\n   */\n  public cleanup(): void {\n    this.lazyIndexes.clear()\n    this.resolvedIndexes.clear()\n  }\n}\n"],"names":["createSingleRowRefProxy","toExpression","BTreeIndex","lazyIndex","LazyIndexWrapper","IndexProxy"],"mappings":"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"}

package/dist/cjs/collection/indexes.d.cts

@@ -0,0 +1,47 @@
+import { IndexProxy, LazyIndexWrapper } from '../indexes/lazy-index.cjs';
+import { BTreeIndex } from '../indexes/btree-index.cjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { BaseIndex, IndexResolver } from '../indexes/base-index.cjs';
+import { ChangeMessage } from '../types.cjs';
+import { IndexOptions } from '../indexes/index-options.cjs';
+import { SingleRowRefProxy } from '../query/builder/ref-proxy.cjs';
+import { CollectionLifecycleManager } from './lifecycle.cjs';
+import { CollectionStateManager } from './state.cjs';
+export declare class CollectionIndexesManager<TOutput extends object = Record<string, unknown>, TKey extends string | number = string | number, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInput extends object = TOutput> {
+    private lifecycle;
+    private state;
+    lazyIndexes: Map<number, LazyIndexWrapper<TKey>>;
+    resolvedIndexes: Map<number, BaseIndex<TKey>>;
+    isIndexesResolved: boolean;
+    indexCounter: number;
+    constructor();
+    setDeps(deps: {
+        state: CollectionStateManager<TOutput, TKey, TSchema, TInput>;
+        lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>;
+    }): void;
+    /**
+     * Creates an index on a collection for faster queries.
+     */
+    createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(indexCallback: (row: SingleRowRefProxy<TOutput>) => any, config?: IndexOptions<TResolver>): IndexProxy<TKey>;
+    /**
+     * Resolve all lazy indexes (called when collection first syncs)
+     */
+    resolveAllIndexes(): Promise<void>;
+    /**
+     * Resolve a single index immediately
+     */
+    private resolveSingleIndex;
+    /**
+     * Get resolved indexes for query optimization
+     */
+    get indexes(): Map<number, BaseIndex<TKey>>;
+    /**
+     * Updates all indexes when the collection changes
+     */
+    updateIndexes(changes: Array<ChangeMessage<TOutput, TKey>>): void;
+    /**
+     * Clean up the collection by stopping sync and clearing data
+     * This can be called manually or automatically by garbage collection
+     */
+    cleanup(): void;
+}