@tanstack/db 0.5.33 → 0.6.0

package/src/virtual-props.ts

@@ -0,0 +1,282 @@
+/**
+ * Virtual Properties for TanStack DB
+ *
+ * Virtual properties are computed, read-only properties that provide metadata about rows
+ * (sync status, source, selection state) without being part of the persisted data model.
+ *
+ * Virtual properties are prefixed with `$` to distinguish them from user data fields.
+ * User schemas should not include `$`-prefixed fields as they are reserved.
+ */
+
+/**
+ * Origin of the last confirmed change to a row, from the current client's perspective.
+ *
+ * - `'local'`: The change originated from this client (e.g., a mutation made here)
+ * - `'remote'`: The change was received via sync from another client/server
+ *
+ * Note: This reflects the client's perspective, not the original creator.
+ * User A creates order → $origin = 'local' on User A's client
+ * Order syncs to server
+ * User B receives order → $origin = 'remote' on User B's client
+ */
+export type VirtualOrigin = 'local' | 'remote'
+
+/**
+ * Virtual properties available on every row in TanStack DB collections.
+ *
+ * These properties are:
+ * - Computed (not stored in the data model)
+ * - Read-only (cannot be mutated directly)
+ * - Available in queries (WHERE, ORDER BY, SELECT)
+ * - Included when spreading rows (`...user`)
+ *
+ * @template TKey - The type of the row's key (string or number)
+ *
+ * @example
+ * ```typescript
+ * // Accessing virtual properties on a row
+ * const user = collection.get('user-1')
+ * if (user.$synced) {
+ *   console.log('Confirmed by backend')
+ * }
+ * if (user.$origin === 'local') {
+ *   console.log('Created/modified locally')
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using virtual properties in queries
+ * const confirmedOrders = createLiveQueryCollection({
+ *   query: (q) => q
+ *     .from({ order: orders })
+ *     .where(({ order }) => eq(order.$synced, true))
+ * })
+ * ```
+ */
+export interface VirtualRowProps<
+  TKey extends string | number = string | number,
+> {
+  /**
+   * Whether this row reflects confirmed state from the backend.
+   *
+   * - `true`: Row is confirmed by the backend (no pending optimistic mutations)
+   * - `false`: Row has pending optimistic mutations that haven't been confirmed
+   *
+   * For local-only collections (no sync), this is always `true`.
+   * For live query collections, this is passed through from the source collection.
+   */
+  readonly $synced: boolean
+
+  /**
+   * Origin of the last confirmed change to this row, from the current client's perspective.
+   *
+   * - `'local'`: The change originated from this client
+   * - `'remote'`: The change was received via sync
+   *
+   * For local-only collections, this is always `'local'`.
+   * For live query collections, this is passed through from the source collection.
+   */
+  readonly $origin: VirtualOrigin
+
+  /**
+   * The row's key (primary identifier).
+   *
+   * This is the same value returned by `collection.config.getKey(row)`.
+   * Useful when you need the key in projections or computations.
+   */
+  readonly $key: TKey
+
+  /**
+   * The ID of the source collection this row originated from.
+   *
+   * In joins, this can help identify which collection each row came from.
+   * For live query collections, this is the ID of the upstream collection.
+   */
+  readonly $collectionId: string
+}
+
+/**
+ * Adds virtual properties to a row type.
+ *
+ * @template T - The base row type
+ * @template TKey - The type of the row's key
+ *
+ * @example
+ * ```typescript
+ * type User = { id: string; name: string }
+ * type UserWithVirtual = WithVirtualProps<User, string>
+ * // { id: string; name: string; $synced: boolean; $origin: 'local' | 'remote'; $key: string; $collectionId: string }
+ * ```
+ */
+export type WithVirtualProps<
+  T extends object,
+  TKey extends string | number = string | number,
+> = T & VirtualRowProps<TKey>
+
+/**
+ * Extracts the base type from a type that may have virtual properties.
+ * Useful when you need to work with the raw data without virtual properties.
+ *
+ * @template T - The type that may include virtual properties
+ *
+ * @example
+ * ```typescript
+ * type UserWithVirtual = { id: string; name: string; $synced: boolean; $origin: 'local' | 'remote' }
+ * type User = WithoutVirtualProps<UserWithVirtual>
+ * // { id: string; name: string }
+ * ```
+ */
+export type WithoutVirtualProps<T> = Omit<T, keyof VirtualRowProps>
+
+/**
+ * Checks if a value has virtual properties attached.
+ *
+ * @param value - The value to check
+ * @returns true if the value has virtual properties
+ *
+ * @example
+ * ```typescript
+ * if (hasVirtualProps(row)) {
+ *   console.log('Synced:', row.$synced)
+ * }
+ * ```
+ */
+export function hasVirtualProps(
+  value: unknown,
+): value is VirtualRowProps<string | number> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    VIRTUAL_PROP_NAMES.every((name) => name in value)
+  )
+}
+
+/**
+ * Creates virtual properties for a row in a source collection.
+ *
+ * This is the internal function used by collections to add virtual properties
+ * to rows when emitting change messages.
+ *
+ * @param key - The row's key
+ * @param collectionId - The collection's ID
+ * @param isSynced - Whether the row is synced (not optimistic)
+ * @param origin - Whether the change was local or remote
+ * @returns Virtual properties object to merge with the row
+ *
+ * @internal
+ */
+export function createVirtualProps<TKey extends string | number>(
+  key: TKey,
+  collectionId: string,
+  isSynced: boolean,
+  origin: VirtualOrigin,
+): VirtualRowProps<TKey> {
+  return {
+    $synced: isSynced,
+    $origin: origin,
+    $key: key,
+    $collectionId: collectionId,
+  }
+}
+
+/**
+ * Enriches a row with virtual properties using the "add-if-missing" pattern.
+ *
+ * If the row already has virtual properties (from an upstream collection),
+ * they are preserved. If not, new virtual properties are computed and added.
+ *
+ * This is the key function that enables pass-through semantics for nested
+ * live query collections.
+ *
+ * @param row - The row to enrich
+ * @param key - The row's key
+ * @param collectionId - The collection's ID
+ * @param computeSynced - Function to compute $synced if missing
+ * @param computeOrigin - Function to compute $origin if missing
+ * @returns The row with virtual properties (possibly the same object if already present)
+ *
+ * @internal
+ */
+export function enrichRowWithVirtualProps<
+  T extends object,
+  TKey extends string | number,
+>(
+  row: T,
+  key: TKey,
+  collectionId: string,
+  computeSynced: () => boolean,
+  computeOrigin: () => VirtualOrigin,
+): WithVirtualProps<T, TKey> {
+  // Use nullish coalescing to preserve existing virtual properties (pass-through)
+  // This is the "add-if-missing" pattern described in the RFC
+  const existingRow = row as Partial<VirtualRowProps<TKey>>
+
+  return {
+    ...row,
+    $synced: existingRow.$synced ?? computeSynced(),
+    $origin: existingRow.$origin ?? computeOrigin(),
+    $key: existingRow.$key ?? key,
+    $collectionId: existingRow.$collectionId ?? collectionId,
+  } as WithVirtualProps<T, TKey>
+}
+
+/**
+ * Computes aggregate virtual properties for a group of rows.
+ *
+ * For aggregates:
+ * - `$synced`: true if ALL rows in the group are synced; false if ANY row is optimistic
+ * - `$origin`: 'local' if ANY row in the group is local; otherwise 'remote'
+ *
+ * @param rows - The rows in the group
+ * @param groupKey - The group key
+ * @param collectionId - The collection ID
+ * @returns Virtual properties for the aggregate row
+ *
+ * @internal
+ */
+export function computeAggregateVirtualProps<TKey extends string | number>(
+  rows: Array<Partial<VirtualRowProps<string | number>>>,
+  groupKey: TKey,
+  collectionId: string,
+): VirtualRowProps<TKey> {
+  // $synced = true only if ALL rows are synced (false if ANY is optimistic)
+  const allSynced = rows.every((row) => row.$synced ?? true)
+
+  // $origin = 'local' if ANY row is local (consistent with "local influence" semantics)
+  const hasLocal = rows.some((row) => row.$origin === 'local')
+
+  return {
+    $synced: allSynced,
+    $origin: hasLocal ? 'local' : 'remote',
+    $key: groupKey,
+    $collectionId: collectionId,
+  }
+}
+
+/**
+ * List of virtual property names for iteration and checking.
+ * @internal
+ */
+export const VIRTUAL_PROP_NAMES = [
+  '$synced',
+  '$origin',
+  '$key',
+  '$collectionId',
+] as const
+
+/**
+ * Checks if a property name is a virtual property.
+ * @internal
+ */
+export function isVirtualPropName(name: string): boolean {
+  return VIRTUAL_PROP_NAMES.includes(name as any)
+}
+
+/**
+ * Checks whether a property path references a virtual property.
+ * @internal
+ */
+export function hasVirtualPropPath(path: Array<string>): boolean {
+  return path.some((segment) => isVirtualPropName(segment))
+}

package/dist/cjs/indexes/lazy-index.cjs

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function isConstructor(resolver) {
-  return typeof resolver === `function` && resolver.prototype !== void 0 && resolver.prototype.constructor === resolver;
-}
-async function resolveIndexConstructor(resolver) {
-  if (isConstructor(resolver)) {
-    return resolver;
-  } else {
-    return await resolver();
-  }
-}
-class LazyIndexWrapper {
-  constructor(id, expression, name, resolver, options, collectionEntries) {
-    this.id = id;
-    this.expression = expression;
-    this.name = name;
-    this.resolver = resolver;
-    this.options = options;
-    this.collectionEntries = collectionEntries;
-    this.indexPromise = null;
-    this.resolvedIndex = null;
-    if (isConstructor(this.resolver)) {
-      this.resolvedIndex = new this.resolver(
-        this.id,
-        this.expression,
-        this.name,
-        this.options
-      );
-      if (this.collectionEntries) {
-        this.resolvedIndex.build(this.collectionEntries);
-      }
-    }
-  }
-  /**
-   * Resolve the actual index
-   */
-  async resolve() {
-    if (this.resolvedIndex) {
-      return this.resolvedIndex;
-    }
-    if (!this.indexPromise) {
-      this.indexPromise = this.createIndex();
-    }
-    this.resolvedIndex = await this.indexPromise;
-    return this.resolvedIndex;
-  }
-  /**
-   * Check if already resolved
-   */
-  isResolved() {
-    return this.resolvedIndex !== null;
-  }
-  /**
-   * Get resolved index (throws if not ready)
-   */
-  getResolved() {
-    if (!this.resolvedIndex) {
-      throw new Error(
-        `Index ${this.id} has not been resolved yet. Ensure collection is synced.`
-      );
-    }
-    return this.resolvedIndex;
-  }
-  /**
-   * Get the index ID
-   */
-  getId() {
-    return this.id;
-  }
-  /**
-   * Get the index name
-   */
-  getName() {
-    return this.name;
-  }
-  /**
-   * Get the index expression
-   */
-  getExpression() {
-    return this.expression;
-  }
-  async createIndex() {
-    const IndexClass = await resolveIndexConstructor(this.resolver);
-    return new IndexClass(this.id, this.expression, this.name, this.options);
-  }
-}
-class IndexProxy {
-  constructor(indexId, lazyIndex) {
-    this.indexId = indexId;
-    this.lazyIndex = lazyIndex;
-  }
-  /**
-   * Get the resolved index (throws if not ready)
-   */
-  get index() {
-    return this.lazyIndex.getResolved();
-  }
-  /**
-   * Check if index is ready
-   */
-  get isReady() {
-    return this.lazyIndex.isResolved();
-  }
-  /**
-   * Wait for index to be ready
-   */
-  async whenReady() {
-    return await this.lazyIndex.resolve();
-  }
-  /**
-   * Get the index ID
-   */
-  get id() {
-    return this.indexId;
-  }
-  /**
-   * Get the index name (throws if not ready)
-   */
-  get name() {
-    if (this.isReady) {
-      return this.index.name;
-    }
-    return this.lazyIndex.getName();
-  }
-  /**
-   * Get the index expression (available immediately)
-   */
-  get expression() {
-    return this.lazyIndex.getExpression();
-  }
-  /**
-   * Check if index supports an operation (throws if not ready)
-   */
-  supports(operation) {
-    return this.index.supports(operation);
-  }
-  /**
-   * Get index statistics (throws if not ready)
-   */
-  getStats() {
-    return this.index.getStats();
-  }
-  /**
-   * Check if index matches a field path (available immediately)
-   */
-  matchesField(fieldPath) {
-    const expr = this.expression;
-    return expr.type === `ref` && expr.path.length === fieldPath.length && expr.path.every((part, i) => part === fieldPath[i]);
-  }
-  /**
-   * Get the key count (throws if not ready)
-   */
-  get keyCount() {
-    return this.index.keyCount;
-  }
-  // Test compatibility properties - delegate to resolved index
-  get indexedKeysSet() {
-    const resolved = this.index;
-    return resolved.indexedKeysSet;
-  }
-  get orderedEntriesArray() {
-    const resolved = this.index;
-    return resolved.orderedEntriesArray;
-  }
-  get valueMapData() {
-    const resolved = this.index;
-    return resolved.valueMapData;
-  }
-  // BTreeIndex compatibility methods
-  equalityLookup(value) {
-    const resolved = this.index;
-    return resolved.equalityLookup?.(value) ?? /* @__PURE__ */ new Set();
-  }
-  rangeQuery(options) {
-    const resolved = this.index;
-    return resolved.rangeQuery?.(options) ?? /* @__PURE__ */ new Set();
-  }
-  inArrayLookup(values) {
-    const resolved = this.index;
-    return resolved.inArrayLookup?.(values) ?? /* @__PURE__ */ new Set();
-  }
-  // Internal method for the collection to get the lazy wrapper
-  _getLazyWrapper() {
-    return this.lazyIndex;
-  }
-}
-exports.IndexProxy = IndexProxy;
-exports.LazyIndexWrapper = LazyIndexWrapper;
-//# sourceMappingURL=lazy-index.cjs.map

package/dist/cjs/indexes/lazy-index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy-index.cjs","sources":["../../../src/indexes/lazy-index.ts"],"sourcesContent":["import type {\n  BaseIndex,\n  IndexConstructor,\n  IndexResolver,\n} from './base-index.js'\nimport type { BasicExpression } from '../query/ir.js'\n\n/**\n * Utility to determine if a resolver is a constructor or async loader\n */\nfunction isConstructor<TKey extends string | number>(\n  resolver: IndexResolver<TKey>,\n): resolver is IndexConstructor<TKey> {\n  // Check if it's a function with a prototype (constructor)\n  return (\n    typeof resolver === `function` &&\n    resolver.prototype !== undefined &&\n    resolver.prototype.constructor === resolver\n  )\n}\n\n/**\n * Resolve index constructor from resolver\n */\nasync function resolveIndexConstructor<TKey extends string | number>(\n  resolver: IndexResolver<TKey>,\n): Promise<IndexConstructor<TKey>> {\n  if (isConstructor(resolver)) {\n    return resolver\n  } else {\n    // It's an async loader function\n    return await resolver()\n  }\n}\n\n/**\n * Wrapper that defers index creation until first sync\n */\nexport class LazyIndexWrapper<TKey extends string | number = string | number> {\n  private indexPromise: Promise<BaseIndex<TKey>> | null = null\n  private resolvedIndex: BaseIndex<TKey> | null = null\n\n  constructor(\n    private id: number,\n    private expression: BasicExpression,\n    private name: string | undefined,\n    private resolver: IndexResolver<TKey>,\n    private options: any,\n    private collectionEntries?: Iterable<[TKey, any]>,\n  ) {\n    // For synchronous constructors, resolve immediately\n    if (isConstructor(this.resolver)) {\n      this.resolvedIndex = new this.resolver(\n        this.id,\n        this.expression,\n        this.name,\n        this.options,\n      )\n      // Build with initial data if provided\n      if (this.collectionEntries) {\n        this.resolvedIndex.build(this.collectionEntries)\n      }\n    }\n  }\n\n  /**\n   * Resolve the actual index\n   */\n  async resolve(): Promise<BaseIndex<TKey>> {\n    if (this.resolvedIndex) {\n      return this.resolvedIndex\n    }\n\n    if (!this.indexPromise) {\n      this.indexPromise = this.createIndex()\n    }\n\n    this.resolvedIndex = await this.indexPromise\n    return this.resolvedIndex\n  }\n\n  /**\n   * Check if already resolved\n   */\n  isResolved(): boolean {\n    return this.resolvedIndex !== null\n  }\n\n  /**\n   * Get resolved index (throws if not ready)\n   */\n  getResolved(): BaseIndex<TKey> {\n    if (!this.resolvedIndex) {\n      throw new Error(\n        `Index ${this.id} has not been resolved yet. Ensure collection is synced.`,\n      )\n    }\n    return this.resolvedIndex\n  }\n\n  /**\n   * Get the index ID\n   */\n  getId(): number {\n    return this.id\n  }\n\n  /**\n   * Get the index name\n   */\n  getName(): string | undefined {\n    return this.name\n  }\n\n  /**\n   * Get the index expression\n   */\n  getExpression(): BasicExpression {\n    return this.expression\n  }\n\n  private async createIndex(): Promise<BaseIndex<TKey>> {\n    const IndexClass = await resolveIndexConstructor(this.resolver)\n    return new IndexClass(this.id, this.expression, this.name, this.options)\n  }\n}\n\n/**\n * Proxy that provides synchronous interface while index loads asynchronously\n */\nexport class IndexProxy<TKey extends string | number = string | number> {\n  constructor(\n    private indexId: number,\n    private lazyIndex: LazyIndexWrapper<TKey>,\n  ) {}\n\n  /**\n   * Get the resolved index (throws if not ready)\n   */\n  get index(): BaseIndex<TKey> {\n    return this.lazyIndex.getResolved()\n  }\n\n  /**\n   * Check if index is ready\n   */\n  get isReady(): boolean {\n    return this.lazyIndex.isResolved()\n  }\n\n  /**\n   * Wait for index to be ready\n   */\n  async whenReady(): Promise<BaseIndex<TKey>> {\n    return await this.lazyIndex.resolve()\n  }\n\n  /**\n   * Get the index ID\n   */\n  get id(): number {\n    return this.indexId\n  }\n\n  /**\n   * Get the index name (throws if not ready)\n   */\n  get name(): string | undefined {\n    if (this.isReady) {\n      return this.index.name\n    }\n    return this.lazyIndex.getName()\n  }\n\n  /**\n   * Get the index expression (available immediately)\n   */\n  get expression(): BasicExpression {\n    return this.lazyIndex.getExpression()\n  }\n\n  /**\n   * Check if index supports an operation (throws if not ready)\n   */\n  supports(operation: any): boolean {\n    return this.index.supports(operation)\n  }\n\n  /**\n   * Get index statistics (throws if not ready)\n   */\n  getStats() {\n    return this.index.getStats()\n  }\n\n  /**\n   * Check if index matches a field path (available immediately)\n   */\n  matchesField(fieldPath: Array<string>): boolean {\n    const expr = this.expression\n    return (\n      expr.type === `ref` &&\n      expr.path.length === fieldPath.length &&\n      expr.path.every((part, i) => part === fieldPath[i])\n    )\n  }\n\n  /**\n   * Get the key count (throws if not ready)\n   */\n  get keyCount(): number {\n    return this.index.keyCount\n  }\n\n  // Test compatibility properties - delegate to resolved index\n  get indexedKeysSet(): Set<TKey> {\n    const resolved = this.index as any\n    return resolved.indexedKeysSet\n  }\n\n  get orderedEntriesArray(): Array<[any, Set<TKey>]> {\n    const resolved = this.index as any\n    return resolved.orderedEntriesArray\n  }\n\n  get valueMapData(): Map<any, Set<TKey>> {\n    const resolved = this.index as any\n    return resolved.valueMapData\n  }\n\n  // BTreeIndex compatibility methods\n  equalityLookup(value: any): Set<TKey> {\n    const resolved = this.index as any\n    return resolved.equalityLookup?.(value) ?? new Set()\n  }\n\n  rangeQuery(options: any): Set<TKey> {\n    const resolved = this.index as any\n    return resolved.rangeQuery?.(options) ?? new Set()\n  }\n\n  inArrayLookup(values: Array<any>): Set<TKey> {\n    const resolved = this.index as any\n    return resolved.inArrayLookup?.(values) ?? new Set()\n  }\n\n  // Internal method for the collection to get the lazy wrapper\n  _getLazyWrapper(): LazyIndexWrapper<TKey> {\n    return this.lazyIndex\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/cjs/indexes/lazy-index.d.cts

@@ -1,96 +0,0 @@
-import { BaseIndex, IndexResolver } from './base-index.js';
-import { BasicExpression } from '../query/ir.js';
-/**
- * Wrapper that defers index creation until first sync
- */
-export declare class LazyIndexWrapper<TKey extends string | number = string | number> {
-    private id;
-    private expression;
-    private name;
-    private resolver;
-    private options;
-    private collectionEntries?;
-    private indexPromise;
-    private resolvedIndex;
-    constructor(id: number, expression: BasicExpression, name: string | undefined, resolver: IndexResolver<TKey>, options: any, collectionEntries?: Iterable<[TKey, any]> | undefined);
-    /**
-     * Resolve the actual index
-     */
-    resolve(): Promise<BaseIndex<TKey>>;
-    /**
-     * Check if already resolved
-     */
-    isResolved(): boolean;
-    /**
-     * Get resolved index (throws if not ready)
-     */
-    getResolved(): BaseIndex<TKey>;
-    /**
-     * Get the index ID
-     */
-    getId(): number;
-    /**
-     * Get the index name
-     */
-    getName(): string | undefined;
-    /**
-     * Get the index expression
-     */
-    getExpression(): BasicExpression;
-    private createIndex;
-}
-/**
- * Proxy that provides synchronous interface while index loads asynchronously
- */
-export declare class IndexProxy<TKey extends string | number = string | number> {
-    private indexId;
-    private lazyIndex;
-    constructor(indexId: number, lazyIndex: LazyIndexWrapper<TKey>);
-    /**
-     * Get the resolved index (throws if not ready)
-     */
-    get index(): BaseIndex<TKey>;
-    /**
-     * Check if index is ready
-     */
-    get isReady(): boolean;
-    /**
-     * Wait for index to be ready
-     */
-    whenReady(): Promise<BaseIndex<TKey>>;
-    /**
-     * Get the index ID
-     */
-    get id(): number;
-    /**
-     * Get the index name (throws if not ready)
-     */
-    get name(): string | undefined;
-    /**
-     * Get the index expression (available immediately)
-     */
-    get expression(): BasicExpression;
-    /**
-     * Check if index supports an operation (throws if not ready)
-     */
-    supports(operation: any): boolean;
-    /**
-     * Get index statistics (throws if not ready)
-     */
-    getStats(): import('./base-index.js').IndexStats;
-    /**
-     * Check if index matches a field path (available immediately)
-     */
-    matchesField(fieldPath: Array<string>): boolean;
-    /**
-     * Get the key count (throws if not ready)
-     */
-    get keyCount(): number;
-    get indexedKeysSet(): Set<TKey>;
-    get orderedEntriesArray(): Array<[any, Set<TKey>]>;
-    get valueMapData(): Map<any, Set<TKey>>;
-    equalityLookup(value: any): Set<TKey>;
-    rangeQuery(options: any): Set<TKey>;
-    inArrayLookup(values: Array<any>): Set<TKey>;
-    _getLazyWrapper(): LazyIndexWrapper<TKey>;
-}

package/dist/esm/indexes/lazy-index.d.ts

@@ -1,96 +0,0 @@
-import { BaseIndex, IndexResolver } from './base-index.js';
-import { BasicExpression } from '../query/ir.js';
-/**
- * Wrapper that defers index creation until first sync
- */
-export declare class LazyIndexWrapper<TKey extends string | number = string | number> {
-    private id;
-    private expression;
-    private name;
-    private resolver;
-    private options;
-    private collectionEntries?;
-    private indexPromise;
-    private resolvedIndex;
-    constructor(id: number, expression: BasicExpression, name: string | undefined, resolver: IndexResolver<TKey>, options: any, collectionEntries?: Iterable<[TKey, any]> | undefined);
-    /**
-     * Resolve the actual index
-     */
-    resolve(): Promise<BaseIndex<TKey>>;
-    /**
-     * Check if already resolved
-     */
-    isResolved(): boolean;
-    /**
-     * Get resolved index (throws if not ready)
-     */
-    getResolved(): BaseIndex<TKey>;
-    /**
-     * Get the index ID
-     */
-    getId(): number;
-    /**
-     * Get the index name
-     */
-    getName(): string | undefined;
-    /**
-     * Get the index expression
-     */
-    getExpression(): BasicExpression;
-    private createIndex;
-}
-/**
- * Proxy that provides synchronous interface while index loads asynchronously
- */
-export declare class IndexProxy<TKey extends string | number = string | number> {
-    private indexId;
-    private lazyIndex;
-    constructor(indexId: number, lazyIndex: LazyIndexWrapper<TKey>);
-    /**
-     * Get the resolved index (throws if not ready)
-     */
-    get index(): BaseIndex<TKey>;
-    /**
-     * Check if index is ready
-     */
-    get isReady(): boolean;
-    /**
-     * Wait for index to be ready
-     */
-    whenReady(): Promise<BaseIndex<TKey>>;
-    /**
-     * Get the index ID
-     */
-    get id(): number;
-    /**
-     * Get the index name (throws if not ready)
-     */
-    get name(): string | undefined;
-    /**
-     * Get the index expression (available immediately)
-     */
-    get expression(): BasicExpression;
-    /**
-     * Check if index supports an operation (throws if not ready)
-     */
-    supports(operation: any): boolean;
-    /**
-     * Get index statistics (throws if not ready)
-     */
-    getStats(): import('./base-index.js').IndexStats;
-    /**
-     * Check if index matches a field path (available immediately)
-     */
-    matchesField(fieldPath: Array<string>): boolean;
-    /**
-     * Get the key count (throws if not ready)
-     */
-    get keyCount(): number;
-    get indexedKeysSet(): Set<TKey>;
-    get orderedEntriesArray(): Array<[any, Set<TKey>]>;
-    get valueMapData(): Map<any, Set<TKey>>;
-    equalityLookup(value: any): Set<TKey>;
-    rangeQuery(options: any): Set<TKey>;
-    inArrayLookup(values: Array<any>): Set<TKey>;
-    _getLazyWrapper(): LazyIndexWrapper<TKey>;
-}