@topgunbuild/core 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1161,7 +1161,7 @@ declare function serialize(data: unknown): Uint8Array;
  */
 declare function deserialize<T = unknown>(data: Uint8Array | ArrayBuffer): T;
 
-type PredicateOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'regex' | 'and' | 'or' | 'not';
+type PredicateOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'regex' | 'contains' | 'containsAll' | 'containsAny' | 'and' | 'or' | 'not';
 interface PredicateNode {
     op: PredicateOp;
     attribute?: string;
@@ -1181,6 +1181,30 @@ declare class Predicates {
     static and(...predicates: PredicateNode[]): PredicateNode;
     static or(...predicates: PredicateNode[]): PredicateNode;
     static not(predicate: PredicateNode): PredicateNode;
+    /**
+     * Create a 'contains' predicate for text search.
+     * Matches if attribute value contains the search text.
+     *
+     * @param attribute - Attribute name
+     * @param value - Text to search for
+     */
+    static contains(attribute: string, value: string): PredicateNode;
+    /**
+     * Create a 'containsAll' predicate for text search.
+     * Matches if attribute value contains ALL search values.
+     *
+     * @param attribute - Attribute name
+     * @param values - Text values that must all be present
+     */
+    static containsAll(attribute: string, values: string[]): PredicateNode;
+    /**
+     * Create a 'containsAny' predicate for text search.
+     * Matches if attribute value contains ANY search value.
+     *
+     * @param attribute - Attribute name
+     * @param values - Text values, any of which can match
+     */
+    static containsAny(attribute: string, values: string[]): PredicateNode;
 }
 declare function evaluatePredicate(predicate: PredicateNode, data: any): boolean;
 
@@ -2465,7 +2489,7 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         keyPattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>], "type">;
-type Query = z.infer<typeof QuerySchema>;
+type Query$1 = z.infer<typeof QuerySchema>;
 type ClientOp = z.infer<typeof ClientOpSchema>;
 type Message = z.infer<typeof MessageSchema>;
 type PingMessage = z.infer<typeof PingMessageSchema>;
@@ -2962,4 +2986,3897 @@ type ReplicationProtocolMessage = ReplicationMessage | ReplicationBatchMessage |
 declare const PARTITION_COUNT = 271;
 declare const DEFAULT_BACKUP_COUNT = 1;
 
-export { AuthMessageSchema, type BatchMessage, BatchMessageSchema, BuiltInProcessors, BuiltInResolvers, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type ConflictResolver, type ConflictResolverDef, ConflictResolverDefSchema, type ConflictResolverFn, ConflictResolverSchema, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, CounterRequestSchema, CounterResponseSchema, CounterSyncSchema, CounterUpdateSchema, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_EVENT_JOURNAL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_PROCESSOR_RATE_LIMITS, DEFAULT_REPLICATION_CONFIG, DEFAULT_RESOLVER_RATE_LIMITS, DEFAULT_WRITE_CONCERN_TIMEOUT, type EntryProcessBatchRequest, EntryProcessBatchRequestSchema, type EntryProcessBatchResponse, EntryProcessBatchResponseSchema, type EntryProcessKeyResult, EntryProcessKeyResultSchema, type EntryProcessRequest, EntryProcessRequestSchema, type EntryProcessResponse, EntryProcessResponseSchema, type EntryProcessorDef, EntryProcessorDefSchema, type EntryProcessorFn, type EntryProcessorResult, EntryProcessorSchema, type EventJournal, type EventJournalConfig, EventJournalImpl, FORBIDDEN_PATTERNS, HLC, type JournalEvent, type JournalEventData, JournalEventDataSchema, type JournalEventInput, type JournalEventListener, type JournalEventMessage, JournalEventMessageSchema, type JournalEventType, JournalEventTypeSchema, type JournalReadRequest, JournalReadRequestSchema, type JournalReadResponse, JournalReadResponseSchema, type JournalSubscribeRequest, JournalSubscribeRequestSchema, type JournalUnsubscribeRequest, JournalUnsubscribeRequestSchema, LWWMap, type LWWRecord, LWWRecordSchema, type ListResolversRequest, ListResolversRequestSchema, type ListResolversResponse, ListResolversResponseSchema, LockReleaseSchema, LockRequestSchema, type MergeContext, type MergeKeyResult, type MergeRejectedMessage, MergeRejectedMessageSchema, type MergeRejection, type MergeResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapRecord, ORMapRecordSchema, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PNCounter, type PNCounterConfig, PNCounterImpl, type PNCounterState, type PNCounterStateObject, PNCounterStateObjectSchema, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PongMessage, PongMessageSchema, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type ProcessorRateLimitConfig, type Query, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, RESOLVER_FORBIDDEN_PATTERNS, type RegisterResolverRequest, RegisterResolverRequestSchema, type RegisterResolverResponse, RegisterResolverResponseSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type ResolverRateLimitConfig, Ringbuffer, type RoutingError, type StaleMapError, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type Timestamp, TimestampSchema, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, type UnregisterResolverRequest, UnregisterResolverRequestSchema, type UnregisterResolverResponse, UnregisterResolverResponseSchema, WRITE_CONCERN_ORDER, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareHLCTimestamps, compareTimestamps, deepMerge, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isUsingNativeHash, isWriteConcernAchieved, resetNativeHash, serialize, timestampToString, validateProcessorCode, validateResolverCode };
+/**
+ * Common types for sorted data structures
+ */
+/**
+ * Comparator function for ordering keys
+ */
+type Comparator<K> = (a: K, b: K) => number;
+/**
+ * Options for range queries
+ */
+interface RangeOptions {
+    /** Include the lower bound in results (default: true) */
+    fromInclusive?: boolean;
+    /** Include the upper bound in results (default: false) */
+    toInclusive?: boolean;
+}
+
+/**
+ * Type-safe wrapper over sorted-btree for use in NavigableIndex
+ *
+ * Provides O(log N) operations for:
+ * - set/get/delete
+ * - range queries
+ * - greaterThan/lessThan queries
+ */
+
+/**
+ * A sorted map implementation backed by a B+ tree.
+ * Provides efficient range queries and ordered iteration.
+ *
+ * @template K - Key type (must be comparable)
+ * @template V - Value type
+ */
+declare class SortedMap<K, V> {
+    private readonly tree;
+    private readonly comparator;
+    constructor(comparator?: Comparator<K>);
+    /**
+     * Set a key-value pair. Updates existing key if present.
+     * Time complexity: O(log N)
+     */
+    set(key: K, value: V): this;
+    /**
+     * Get the value for a key.
+     * Time complexity: O(log N)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Delete a key from the map.
+     * Time complexity: O(log N)
+     * @returns true if the key existed and was deleted
+     */
+    delete(key: K): boolean;
+    /**
+     * Check if a key exists in the map.
+     * Time complexity: O(log N)
+     */
+    has(key: K): boolean;
+    /**
+     * Get the number of entries in the map.
+     */
+    get size(): number;
+    /**
+     * Check if the map is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get the minimum key in the map.
+     * Time complexity: O(log N)
+     */
+    minKey(): K | undefined;
+    /**
+     * Get the maximum key in the map.
+     * Time complexity: O(log N)
+     */
+    maxKey(): K | undefined;
+    /**
+     * Iterate over entries in a range [from, to).
+     * Time complexity: O(log N + K) where K is the number of results
+     *
+     * @param from - Lower bound
+     * @param to - Upper bound
+     * @param options - Range options for inclusive/exclusive bounds
+     */
+    range(from: K, to: K, options?: RangeOptions): IterableIterator<[K, V]>;
+    /**
+     * Iterate over entries where key > value (or >= if inclusive).
+     * Time complexity: O(log N + K) where K is the number of results
+     *
+     * @param key - Lower bound
+     * @param inclusive - Include the bound in results (default: false)
+     */
+    greaterThan(key: K, inclusive?: boolean): IterableIterator<[K, V]>;
+    /**
+     * Iterate over entries where key < value (or <= if inclusive).
+     * Time complexity: O(log N + K) where K is the number of results
+     *
+     * Note: This method iterates from the beginning of the tree.
+     * The O(log N) component is for finding the upper bound,
+     * and O(K) is for yielding K results.
+     *
+     * @param key - Upper bound
+     * @param inclusive - Include the bound in results (default: false)
+     */
+    lessThan(key: K, inclusive?: boolean): IterableIterator<[K, V]>;
+    /**
+     * Iterate over all entries in sorted order.
+     * Time complexity: O(N)
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Iterate over all keys in sorted order.
+     * Time complexity: O(N)
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Iterate over all values in sorted order.
+     * Time complexity: O(N)
+     */
+    values(): IterableIterator<V>;
+    /**
+     * Iterate over entries in reverse sorted order.
+     * Time complexity: O(N)
+     */
+    entriesReversed(): IterableIterator<[K, V]>;
+    /**
+     * Remove all entries from the map.
+     */
+    clear(): void;
+    /**
+     * Execute a callback for each entry in sorted order.
+     */
+    forEach(callback: (value: V, key: K, map: this) => void): void;
+    /**
+     * Create a new SortedMap from entries.
+     */
+    static from<K, V>(entries: Iterable<[K, V]>, comparator?: Comparator<K>): SortedMap<K, V>;
+    /**
+     * Get or set a value using a factory function.
+     * If the key doesn't exist, the factory is called to create the value.
+     */
+    getOrSet(key: K, factory: () => V): V;
+    /**
+     * Update a value if the key exists.
+     * @returns true if the key existed and was updated
+     */
+    update(key: K, updater: (value: V) => V): boolean;
+    /**
+     * Get the entry at a specific index (0-based).
+     * Time complexity: O(N) - requires linear scan from the beginning.
+     * Note: B+ trees do not support O(log N) index-based access.
+     */
+    at(index: number): [K, V] | undefined;
+    /**
+     * Find the greatest key less than the given key.
+     * Time complexity: O(log N)
+     */
+    lowerKey(key: K): K | undefined;
+    /**
+     * Find the greatest key less than or equal to the given key.
+     * Time complexity: O(log N)
+     */
+    floorKey(key: K): K | undefined;
+    /**
+     * Find the least key greater than the given key.
+     * Time complexity: O(log N)
+     */
+    higherKey(key: K): K | undefined;
+    /**
+     * Find the least key greater than or equal to the given key.
+     * Time complexity: O(log N)
+     */
+    ceilingKey(key: K): K | undefined;
+    /**
+     * Make the map iterable.
+     */
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+
+/**
+ * Attribute System for Query Engine
+ *
+ * Attributes extract value(s) from records for indexing and querying.
+ * Inspired by CQEngine Attribute<O, A>.
+ *
+ * @module query/Attribute
+ */
+/**
+ * Attribute extracts value(s) from a record.
+ * V = Record value type, A = Attribute value type
+ */
+interface Attribute<V, A> {
+    /** Unique attribute name */
+    readonly name: string;
+    /** Attribute value type */
+    readonly type: 'simple' | 'multi';
+    /**
+     * Extract value from record.
+     * Returns undefined if attribute doesn't exist.
+     */
+    getValue(record: V): A | undefined;
+    /**
+     * For multi-value attributes, returns all values.
+     * For simple attributes, returns single-element array.
+     */
+    getValues(record: V): A[];
+}
+/**
+ * Attribute that returns exactly one value per record.
+ */
+declare class SimpleAttribute<V, A> implements Attribute<V, A> {
+    readonly name: string;
+    private readonly extractor;
+    readonly type: "simple";
+    constructor(name: string, extractor: (record: V) => A | undefined);
+    getValue(record: V): A | undefined;
+    getValues(record: V): A[];
+}
+/**
+ * Factory function for SimpleAttribute.
+ */
+declare function simpleAttribute<V, A>(name: string, extractor: (record: V) => A | undefined): SimpleAttribute<V, A>;
+/**
+ * Attribute that returns zero or more values per record.
+ * Example: tags, categories, roles.
+ */
+declare class MultiValueAttribute<V, A> implements Attribute<V, A> {
+    readonly name: string;
+    private readonly extractor;
+    readonly type: "multi";
+    constructor(name: string, extractor: (record: V) => A[]);
+    getValue(record: V): A | undefined;
+    getValues(record: V): A[];
+}
+/**
+ * Factory function for MultiValueAttribute.
+ */
+declare function multiAttribute<V, A>(name: string, extractor: (record: V) => A[]): MultiValueAttribute<V, A>;
+
+/**
+ * ResultSet Interface
+ *
+ * Lazy result set from index queries.
+ * Inspired by CQEngine ResultSet<O>.
+ *
+ * @module query/resultset/ResultSet
+ */
+/**
+ * Lazy result set from index query.
+ * K = record key type
+ */
+interface ResultSet<K> {
+    /**
+     * Iterate over matching keys.
+     * Lazy evaluation where possible.
+     */
+    [Symbol.iterator](): Iterator<K>;
+    /**
+     * Cost of retrieving these results.
+     * Used by QueryOptimizer for index selection.
+     */
+    getRetrievalCost(): number;
+    /**
+     * Estimated cost of merging/processing these results.
+     * Usually based on result count.
+     */
+    getMergeCost(): number;
+    /**
+     * Check if result set contains key.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get result count.
+     * May require iteration for lazy result sets.
+     */
+    size(): number;
+    /**
+     * Materialize to array.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty.
+     */
+    isEmpty(): boolean;
+}
+
+/**
+ * Base Index Interface
+ *
+ * Defines the contract for all index types in the Query Engine.
+ * Inspired by CQEngine Index hierarchy.
+ *
+ * @module query/indexes/types
+ */
+
+/**
+ * Base interface for all indexes.
+ * K = record key type, V = record value type, A = attribute value type
+ */
+interface Index<K, V, A = unknown> {
+    /** Attribute this index is built on */
+    readonly attribute: Attribute<V, A>;
+    /** Index type identifier */
+    readonly type: 'hash' | 'navigable' | 'compound' | 'standing' | 'inverted';
+    /**
+     * Cost of retrieving results from this index.
+     * Lower is better. Used by QueryOptimizer.
+     * CQEngine values: Standing=10, Compound=20, Hash=30, Navigable=40
+     */
+    getRetrievalCost(): number;
+    /**
+     * Check if this index supports the given query type.
+     */
+    supportsQuery(queryType: string): boolean;
+    /**
+     * Retrieve candidate keys matching the query.
+     */
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    /**
+     * Add a record to the index.
+     */
+    add(key: K, record: V): void;
+    /**
+     * Remove a record from the index.
+     */
+    remove(key: K, record: V): void;
+    /**
+     * Update a record in the index.
+     */
+    update(key: K, oldRecord: V, newRecord: V): void;
+    /**
+     * Clear all entries from the index.
+     */
+    clear(): void;
+    /**
+     * Get statistics about the index.
+     */
+    getStats(): IndexStats;
+}
+/**
+ * Query parameters for index retrieval.
+ */
+interface IndexQuery<A> {
+    /** Query type */
+    type: 'equal' | 'in' | 'has' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'contains' | 'containsAll' | 'containsAny' | 'compound';
+    /** Value for equality queries */
+    value?: A;
+    /** Values for 'in' queries or compound queries */
+    values?: A[];
+    /** Lower bound for range queries */
+    from?: A;
+    /** Upper bound for range queries */
+    to?: A;
+    /** Include lower bound (default: true) */
+    fromInclusive?: boolean;
+    /** Include upper bound (default: false) */
+    toInclusive?: boolean;
+}
+/**
+ * Statistics about an index.
+ */
+interface IndexStats {
+    /** Number of distinct attribute values indexed */
+    distinctValues: number;
+    /** Total number of record references */
+    totalEntries: number;
+    /** Average entries per distinct value */
+    avgEntriesPerValue: number;
+}
+
+/**
+ * HashIndex Implementation
+ *
+ * Hash-based index for O(1) equality lookups.
+ * Supports: equal, in, has queries.
+ *
+ * Structure: Map<AttributeValue, Set<RecordKey>>
+ *
+ * CQEngine Reference: HashIndex.java (retrieval cost: 30)
+ *
+ * @module query/indexes/HashIndex
+ */
+
+/**
+ * Hash-based index for O(1) equality lookups.
+ *
+ * K = record key type, V = record value type, A = attribute value type
+ */
+declare class HashIndex<K, V, A> implements Index<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    readonly type: "hash";
+    /** Map from attribute value to set of record keys */
+    private data;
+    /** Set of all keys with non-null attribute value */
+    private allKeys;
+    private static readonly RETRIEVAL_COST;
+    private static readonly SUPPORTED_QUERIES;
+    constructor(attribute: Attribute<V, A>);
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    private retrieveEqual;
+    private retrieveIn;
+    private retrieveHas;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    private arraysEqual;
+}
+
+/**
+ * NavigableIndex Implementation
+ *
+ * Sorted index for O(log N) range queries.
+ * Supports: equal, in, has, gt, gte, lt, lte, between queries.
+ *
+ * Structure: SortedMap<AttributeValue, Set<RecordKey>>
+ *
+ * CQEngine Reference: NavigableIndex.java (retrieval cost: 40)
+ *
+ * @module query/indexes/NavigableIndex
+ */
+
+/**
+ * Sorted index for O(log N) range queries.
+ *
+ * K = record key type, V = record value type, A = attribute value type (must be orderable)
+ */
+declare class NavigableIndex<K, V, A extends string | number> implements Index<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    readonly type: "navigable";
+    /** Sorted map from attribute value to set of record keys */
+    private data;
+    /** Set of all keys with non-null attribute value */
+    private allKeys;
+    /** Retrieval cost as per CQEngine cost model */
+    private static readonly RETRIEVAL_COST;
+    /** Supported query types */
+    private static readonly SUPPORTED_QUERIES;
+    /**
+     * Create a NavigableIndex.
+     *
+     * @param attribute - Attribute to index
+     * @param comparator - Optional custom comparator for ordering
+     */
+    constructor(attribute: Attribute<V, A>, comparator?: Comparator<A>);
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    private retrieveEqual;
+    private retrieveIn;
+    private retrieveHas;
+    private retrieveGreaterThan;
+    private retrieveLessThan;
+    private retrieveBetween;
+    private iterateGreaterThan;
+    private iterateLessThan;
+    private iterateBetween;
+    /**
+     * Estimate size for gt/gte queries.
+     * Uses rough estimate: assume uniform distribution, return half.
+     */
+    private estimateGreaterThanSize;
+    /**
+     * Estimate size for lt/lte queries.
+     * Uses rough estimate: assume uniform distribution, return half.
+     */
+    private estimateLessThanSize;
+    /**
+     * Estimate size for between queries.
+     * Uses rough estimate: assume uniform distribution, return quarter.
+     */
+    private estimateBetweenSize;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    private arraysEqual;
+    /**
+     * Get the minimum indexed value.
+     * Useful for debugging and range estimation.
+     */
+    getMinValue(): A | undefined;
+    /**
+     * Get the maximum indexed value.
+     * Useful for debugging and range estimation.
+     */
+    getMaxValue(): A | undefined;
+}
+
+/**
+ * Fallback index that performs full scan.
+ * Used when no suitable index exists for a query.
+ *
+ * K = record key type, V = record value type
+ */
+declare class FallbackIndex<K, V> implements Index<K, V, unknown> {
+    private readonly getAllKeys;
+    private readonly getRecord;
+    private readonly matchesPredicate;
+    readonly type: "hash";
+    /** Wildcard attribute for fallback */
+    readonly attribute: SimpleAttribute<V, unknown>;
+    /** Maximum retrieval cost ensures this is only used as fallback */
+    private static readonly RETRIEVAL_COST;
+    /**
+     * Create a FallbackIndex.
+     *
+     * @param getAllKeys - Function to get all keys in the collection
+     * @param getRecord - Function to get a record by key
+     * @param matchesPredicate - Function to check if a record matches a query
+     */
+    constructor(getAllKeys: () => Iterable<K>, getRecord: (key: K) => V | undefined, matchesPredicate: (record: V, query: IndexQuery<unknown>) => boolean);
+    getRetrievalCost(): number;
+    /**
+     * Supports any query type via full scan.
+     */
+    supportsQuery(): boolean;
+    /**
+     * Retrieve by performing full scan and applying predicate.
+     */
+    retrieve(query: IndexQuery<unknown>): ResultSet<K>;
+    add(): void;
+    remove(): void;
+    update(): void;
+    clear(): void;
+    getStats(): IndexStats;
+}
+/**
+ * Factory to create predicate matcher from query.
+ * Used by FallbackIndex to evaluate queries against records.
+ *
+ * @param getAttribute - Function to get attribute value from record
+ */
+declare function createPredicateMatcher<V>(getAttribute: (record: V, attrName: string) => unknown): (record: V, query: IndexQuery<unknown>) => boolean;
+
+/**
+ * Query Types and Plan Types for Query Engine
+ *
+ * Defines query node types for the cost-based optimizer
+ * and execution plan types.
+ *
+ * @module query/QueryTypes
+ */
+
+/**
+ * Base query node interface.
+ * Compatible with existing PredicateNode from predicate.ts
+ */
+interface QueryNode {
+    type: string;
+}
+/**
+ * Simple query node for attribute-based conditions.
+ */
+interface SimpleQueryNode extends QueryNode {
+    type: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'like' | 'regex' | 'in' | 'has' | 'contains' | 'containsAll' | 'containsAny';
+    attribute: string;
+    value?: unknown;
+    values?: unknown[];
+    /** For 'between' queries: lower bound */
+    from?: unknown;
+    /** For 'between' queries: upper bound */
+    to?: unknown;
+    /** For 'between' queries: include lower bound (default: true) */
+    fromInclusive?: boolean;
+    /** For 'between' queries: include upper bound (default: false) */
+    toInclusive?: boolean;
+}
+/**
+ * Logical query node for combining conditions.
+ */
+interface LogicalQueryNode {
+    type: 'and' | 'or' | 'not';
+    children?: Query[];
+    child?: Query;
+}
+/**
+ * Union type for all query types.
+ */
+type Query = SimpleQueryNode | LogicalQueryNode;
+/**
+ * Query execution options for sort/limit/offset.
+ */
+interface QueryOptions {
+    /** Sort by field(s): field name -> direction */
+    sort?: Record<string, 'asc' | 'desc'>;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Number of results to skip */
+    offset?: number;
+}
+/**
+ * Execution plan step.
+ * Represents a single operation in the query execution plan.
+ */
+type PlanStep = IndexScanStep | FullScanStep | IntersectionStep | UnionStep | FilterStep | NotStep;
+/**
+ * Index scan step - retrieves from an index.
+ */
+interface IndexScanStep {
+    type: 'index-scan';
+    index: Index<unknown, unknown, unknown>;
+    query: IndexQuery<unknown>;
+}
+/**
+ * Full scan step - scans all records.
+ */
+interface FullScanStep {
+    type: 'full-scan';
+    predicate: Query;
+}
+/**
+ * Intersection step - AND of multiple result sets.
+ */
+interface IntersectionStep {
+    type: 'intersection';
+    steps: PlanStep[];
+}
+/**
+ * Union step - OR of multiple result sets.
+ */
+interface UnionStep {
+    type: 'union';
+    steps: PlanStep[];
+}
+/**
+ * Filter step - applies predicate to source results.
+ */
+interface FilterStep {
+    type: 'filter';
+    source: PlanStep;
+    predicate: Query;
+}
+/**
+ * NOT step - negation (all keys minus matching keys).
+ */
+interface NotStep {
+    type: 'not';
+    source: PlanStep;
+    allKeys: () => Set<unknown>;
+}
+/**
+ * Complete query execution plan.
+ */
+interface QueryPlan {
+    /** Root execution step */
+    root: PlanStep;
+    /** Estimated execution cost */
+    estimatedCost: number;
+    /** Whether any index is used */
+    usesIndexes: boolean;
+    /** Whether sort can use index order */
+    indexedSort?: boolean;
+    /** Sort configuration */
+    sort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    /** Limit configuration */
+    limit?: number;
+    /** Offset configuration */
+    offset?: number;
+}
+/**
+ * Check if a query is a simple query node.
+ */
+declare function isSimpleQuery(query: Query): query is SimpleQueryNode;
+/**
+ * Check if a query is a logical query node.
+ */
+declare function isLogicalQuery(query: Query): query is LogicalQueryNode;
+
+/**
+ * StandingQueryIndex Implementation
+ *
+ * Pre-computed index for a specific query.
+ * Maintains result set incrementally as data changes.
+ *
+ * Lowest retrieval cost (10) - O(1) query execution.
+ * Critical for Live Queries in TopGun where the same query
+ * is executed repeatedly on every data change.
+ *
+ * CQEngine Reference: StandingQueryIndex.java (retrieval cost: 10)
+ *
+ * @module query/indexes/StandingQueryIndex
+ */
+
+/**
+ * Change type for standing query updates.
+ */
+type StandingQueryChange = 'added' | 'removed' | 'updated' | 'unchanged';
+/**
+ * Options for creating a StandingQueryIndex.
+ */
+interface StandingQueryIndexOptions<K, V> {
+    /** Query this index answers */
+    query: Query;
+    /** Function to get record by key (optional, for validation) */
+    getRecord?: (key: K) => V | undefined;
+}
+/**
+ * Pre-computed index for a specific query.
+ * Maintains result set incrementally as data changes.
+ *
+ * K = record key type, V = record value type
+ */
+declare class StandingQueryIndex<K, V> implements Index<K, V, unknown> {
+    readonly type: "standing";
+    /**
+     * Wildcard attribute - StandingQueryIndex doesn't index by attribute,
+     * it indexes by query match.
+     */
+    readonly attribute: Attribute<V, unknown>;
+    /** Pre-computed result set */
+    private results;
+    /** Query this index answers */
+    private readonly query;
+    /** Record accessor (optional) */
+    private readonly getRecord?;
+    /** Retrieval cost - lowest of all index types */
+    private static readonly RETRIEVAL_COST;
+    constructor(options: StandingQueryIndexOptions<K, V>);
+    /**
+     * Get the query this index answers.
+     */
+    getQuery(): Query;
+    /**
+     * Check if this index answers the given query.
+     */
+    answersQuery(query: Query): boolean;
+    getRetrievalCost(): number;
+    supportsQuery(_queryType: string): boolean;
+    retrieve(_query: IndexQuery<unknown>): ResultSet<K>;
+    /**
+     * Get current result set (for live query updates).
+     * Returns a copy to avoid external mutation.
+     */
+    getResults(): Set<K>;
+    /**
+     * Get result count.
+     */
+    getResultCount(): number;
+    /**
+     * Check if key is in results.
+     */
+    contains(key: K): boolean;
+    add(key: K, record: V): void;
+    remove(key: K, _record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    /**
+     * Determine what changed for a record update.
+     * Returns the type of change relative to the query results.
+     *
+     * @param key - Record key
+     * @param oldRecord - Previous record value (undefined for new records)
+     * @param newRecord - New record value (undefined for deleted records)
+     * @returns Change type: 'added', 'removed', 'updated', or 'unchanged'
+     */
+    determineChange(_key: K, oldRecord: V | undefined, newRecord: V | undefined): StandingQueryChange;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Build index from existing data.
+     *
+     * @param entries - Iterable of [key, record] pairs
+     */
+    buildFromData(entries: Iterable<[K, V]>): void;
+    /**
+     * Evaluate a record against the query predicate.
+     *
+     * @param record - Record to evaluate
+     * @returns true if record matches the query
+     */
+    private evaluateRecord;
+    /**
+     * Evaluate a query node against a record.
+     * Implements predicate evaluation logic.
+     */
+    private evaluateQuery;
+    /**
+     * Evaluate a simple query (attribute-based condition).
+     */
+    private evaluateSimpleQuery;
+    /**
+     * Evaluate a logical query (AND/OR/NOT).
+     */
+    private evaluateLogicalQuery;
+    /**
+     * Get attribute value from record using dot notation.
+     */
+    private getAttributeValue;
+    /**
+     * Match a value against a LIKE pattern.
+     * Supports % as wildcard for any characters.
+     */
+    private matchLike;
+    /**
+     * Deep equality check for queries.
+     */
+    private queriesEqual;
+}
+
+/**
+ * Tokenizer Interface and Implementations
+ *
+ * Provides text tokenization for InvertedIndex full-text search.
+ * Tokenizers split text into searchable tokens.
+ *
+ * @module query/tokenization/Tokenizer
+ */
+/**
+ * Interface for text tokenizers.
+ * Tokenizers split text into an array of tokens (words, n-grams, etc.)
+ */
+interface Tokenizer {
+    /**
+     * Split text into tokens.
+     *
+     * @param text - Text to tokenize
+     * @returns Array of tokens
+     */
+    tokenize(text: string): string[];
+}
+/**
+ * Tokenizer that splits on whitespace.
+ * Simplest tokenizer - splits on any whitespace characters.
+ *
+ * Example: "hello world" → ["hello", "world"]
+ */
+declare class WhitespaceTokenizer implements Tokenizer {
+    tokenize(text: string): string[];
+}
+/**
+ * Tokenizer that splits on word boundaries.
+ * Splits on non-word characters (anything not [a-zA-Z0-9_]).
+ *
+ * Example: "hello-world! test123" → ["hello", "world", "test123"]
+ */
+declare class WordBoundaryTokenizer implements Tokenizer {
+    tokenize(text: string): string[];
+}
+/**
+ * N-gram tokenizer for substring matching.
+ * Creates overlapping character sequences of length n.
+ *
+ * Example (n=3): "hello" → ["hel", "ell", "llo"]
+ *
+ * Use cases:
+ * - Fuzzy search (typo tolerance)
+ * - Substring matching (contains anywhere)
+ * - Partial word matching
+ */
+declare class NGramTokenizer implements Tokenizer {
+    private readonly n;
+    /**
+     * Create an N-gram tokenizer.
+     *
+     * @param n - Length of each n-gram (default: 3)
+     */
+    constructor(n?: number);
+    tokenize(text: string): string[];
+    /**
+     * Get the n-gram size.
+     */
+    get size(): number;
+}
+
+/**
+ * Token Filter Interface and Implementations
+ *
+ * Token filters transform or filter tokens produced by tokenizers.
+ * Common uses: lowercase normalization, stop word removal, length filtering.
+ *
+ * @module query/tokenization/TokenFilter
+ */
+/**
+ * Interface for token filters.
+ * Filters transform an array of tokens into another array of tokens.
+ */
+interface TokenFilter {
+    /**
+     * Apply filter to tokens.
+     *
+     * @param tokens - Input tokens
+     * @returns Filtered tokens
+     */
+    apply(tokens: string[]): string[];
+}
+/**
+ * Filter that converts all tokens to lowercase.
+ * Essential for case-insensitive search.
+ *
+ * Example: ["Hello", "WORLD"] → ["hello", "world"]
+ */
+declare class LowercaseFilter implements TokenFilter {
+    apply(tokens: string[]): string[];
+}
+/**
+ * Default English stop words.
+ * Common words that don't add search value.
+ */
+declare const DEFAULT_STOP_WORDS: string[];
+/**
+ * Filter that removes stop words.
+ * Stop words are common words that don't contribute to search relevance.
+ *
+ * Example: ["the", "quick", "brown", "fox"] → ["quick", "brown", "fox"]
+ */
+declare class StopWordFilter implements TokenFilter {
+    private readonly stopWords;
+    /**
+     * Create a stop word filter.
+     *
+     * @param stopWords - Array of stop words to remove (default: English stop words)
+     */
+    constructor(stopWords?: string[]);
+    apply(tokens: string[]): string[];
+    /**
+     * Get the set of stop words.
+     */
+    getStopWords(): Set<string>;
+}
+/**
+ * Filter that removes tokens shorter than a minimum length.
+ * Useful for filtering out single characters or very short tokens.
+ *
+ * Example (minLength=3): ["a", "is", "the", "quick"] → ["the", "quick"]
+ */
+declare class MinLengthFilter implements TokenFilter {
+    private readonly minLength;
+    /**
+     * Create a minimum length filter.
+     *
+     * @param minLength - Minimum token length (default: 2)
+     */
+    constructor(minLength?: number);
+    apply(tokens: string[]): string[];
+    /**
+     * Get the minimum length setting.
+     */
+    getMinLength(): number;
+}
+/**
+ * Filter that removes tokens longer than a maximum length.
+ * Useful for preventing very long tokens from being indexed.
+ *
+ * Example (maxLength=10): ["short", "verylongword"] → ["short"]
+ */
+declare class MaxLengthFilter implements TokenFilter {
+    private readonly maxLength;
+    /**
+     * Create a maximum length filter.
+     *
+     * @param maxLength - Maximum token length (default: 50)
+     */
+    constructor(maxLength?: number);
+    apply(tokens: string[]): string[];
+    /**
+     * Get the maximum length setting.
+     */
+    getMaxLength(): number;
+}
+/**
+ * Filter that trims whitespace from tokens.
+ * Ensures clean tokens without leading/trailing spaces.
+ */
+declare class TrimFilter implements TokenFilter {
+    apply(tokens: string[]): string[];
+}
+/**
+ * Filter that removes duplicate tokens.
+ * Useful for reducing index size when tokens repeat.
+ *
+ * Example: ["hello", "world", "hello"] → ["hello", "world"]
+ */
+declare class UniqueFilter implements TokenFilter {
+    apply(tokens: string[]): string[];
+}
+
+/**
+ * Tokenization Pipeline
+ *
+ * Chains a tokenizer with multiple filters for text processing.
+ * Provides factory methods for common configurations.
+ *
+ * @module query/tokenization/TokenizationPipeline
+ */
+
+/**
+ * Pipeline configuration options.
+ */
+interface TokenizationPipelineOptions {
+    /** Tokenizer to use */
+    tokenizer: Tokenizer;
+    /** Filters to apply (in order) */
+    filters?: TokenFilter[];
+}
+/**
+ * Tokenization pipeline that chains a tokenizer with filters.
+ *
+ * Processing order:
+ * 1. Tokenizer splits text into tokens
+ * 2. Each filter transforms the token array in sequence
+ *
+ * Example:
+ * ```typescript
+ * const pipeline = TokenizationPipeline.simple();
+ * pipeline.process("Hello World!"); // ["hello", "world"]
+ * ```
+ */
+declare class TokenizationPipeline {
+    private readonly tokenizer;
+    private readonly filters;
+    /**
+     * Create a tokenization pipeline.
+     *
+     * @param options - Pipeline configuration
+     */
+    constructor(options: TokenizationPipelineOptions);
+    /**
+     * Process text through the pipeline.
+     *
+     * @param text - Text to process
+     * @returns Array of processed tokens
+     */
+    process(text: string): string[];
+    /**
+     * Get the tokenizer.
+     */
+    getTokenizer(): Tokenizer;
+    /**
+     * Get the filters.
+     */
+    getFilters(): TokenFilter[];
+    /**
+     * Create a simple pipeline with common defaults.
+     * Uses word boundary tokenizer with lowercase and minimum length filters.
+     *
+     * Configuration:
+     * - Tokenizer: WordBoundaryTokenizer
+     * - Filters: LowercaseFilter, MinLengthFilter(2)
+     *
+     * @returns Simple tokenization pipeline
+     */
+    static simple(): TokenizationPipeline;
+    /**
+     * Create a pipeline optimized for search.
+     * Includes stop word removal for better search relevance.
+     *
+     * Configuration:
+     * - Tokenizer: WordBoundaryTokenizer
+     * - Filters: LowercaseFilter, MinLengthFilter(2), StopWordFilter
+     *
+     * @returns Search-optimized tokenization pipeline
+     */
+    static search(): TokenizationPipeline;
+    /**
+     * Create a minimal pipeline with just tokenization and lowercase.
+     * No filtering - preserves all tokens.
+     *
+     * Configuration:
+     * - Tokenizer: WordBoundaryTokenizer
+     * - Filters: LowercaseFilter
+     *
+     * @returns Minimal tokenization pipeline
+     */
+    static minimal(): TokenizationPipeline;
+    /**
+     * Create a custom pipeline from a tokenizer and filters.
+     *
+     * @param tokenizer - Tokenizer to use
+     * @param filters - Filters to apply
+     * @returns Custom tokenization pipeline
+     */
+    static custom(tokenizer: Tokenizer, filters?: TokenFilter[]): TokenizationPipeline;
+}
+
+/**
+ * InvertedIndex Implementation
+ *
+ * Full-text search index using inverted index structure.
+ * Supports: contains, containsAll, containsAny, has queries.
+ *
+ * Structure:
+ *   tokenIndex: Map<Token, Set<RecordKey>>
+ *   reverseIndex: Map<RecordKey, Set<Token>>
+ *
+ * Retrieval cost: 50 (between NavigableIndex:40 and FallbackIndex)
+ *
+ * @module query/indexes/InvertedIndex
+ */
+
+/**
+ * Extended statistics for InvertedIndex.
+ */
+interface InvertedIndexStats extends IndexStats {
+    /** Total unique tokens in the index */
+    totalTokens: number;
+    /** Average number of tokens per indexed document */
+    avgTokensPerDocument: number;
+    /** Maximum documents for any single token */
+    maxDocumentsPerToken: number;
+}
+/**
+ * Inverted index for full-text search.
+ * Maps tokens to sets of document keys for O(K) query performance.
+ *
+ * K = record key type, V = record value type, A = attribute value type (should be string)
+ */
+declare class InvertedIndex<K, V, A extends string = string> implements Index<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    private readonly pipeline;
+    readonly type: "inverted";
+    /** Token → Set of keys */
+    private tokenIndex;
+    /** Key → Set of tokens (for efficient removal/update) */
+    private reverseIndex;
+    /** All keys with indexed content */
+    private allKeys;
+    private static readonly RETRIEVAL_COST;
+    private static readonly SUPPORTED_QUERIES;
+    /**
+     * Create an InvertedIndex.
+     *
+     * @param attribute - Attribute to index (should return string values)
+     * @param pipeline - Tokenization pipeline (default: simple pipeline)
+     */
+    constructor(attribute: Attribute<V, A>, pipeline?: TokenizationPipeline);
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    /**
+     * Retrieve documents containing all tokens from the search text.
+     * Uses AND semantics - document must contain ALL tokens.
+     */
+    private retrieveContains;
+    /**
+     * Retrieve documents containing ALL specified values.
+     * Each value is tokenized, and ALL resulting tokens must match.
+     */
+    private retrieveContainsAll;
+    /**
+     * Retrieve documents containing ANY of the specified values.
+     * Uses OR semantics - document can contain any token from any value.
+     */
+    private retrieveContainsAny;
+    /**
+     * Retrieve all documents with indexed content.
+     */
+    private retrieveHas;
+    add(key: K, record: V): void;
+    remove(key: K, _record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Get extended statistics for full-text index.
+     */
+    getExtendedStats(): InvertedIndexStats;
+    /**
+     * Get the tokenization pipeline.
+     */
+    getPipeline(): TokenizationPipeline;
+    /**
+     * Check if a specific token exists in the index.
+     */
+    hasToken(token: string): boolean;
+    /**
+     * Get the number of documents for a specific token.
+     */
+    getTokenDocumentCount(token: string): number;
+    private valuesEqual;
+}
+
+/**
+ * CompoundIndex Implementation (Phase 9.03)
+ *
+ * Multi-attribute index for optimizing AND queries.
+ * Creates a composite key from multiple attribute values for O(1) lookup.
+ *
+ * Benefits:
+ * - 100-1000× speedup for compound AND queries
+ * - Eliminates ResultSet intersection overhead
+ * - Single lookup instead of multiple index scans
+ *
+ * @module query/indexes/CompoundIndex
+ */
+
+/**
+ * Options for compound index creation.
+ */
+interface CompoundIndexOptions {
+    /**
+     * Separator for composite key generation.
+     * Default: '|'
+     * Choose a separator that won't appear in attribute values.
+     */
+    separator?: string;
+}
+/**
+ * Compound index for O(1) multi-attribute queries.
+ * Indexes multiple attributes as a single composite key.
+ *
+ * K = record key type, V = record value type
+ */
+declare class CompoundIndex<K, V> implements Index<K, V, unknown> {
+    readonly type: "compound";
+    /** Attributes that make up this compound index (in order) */
+    private readonly _attributes;
+    /** Map from composite key to set of record keys */
+    private data;
+    /** Set of all indexed keys */
+    private allKeys;
+    /** Key separator */
+    private readonly separator;
+    /** Retrieval cost (lower than individual indexes combined) */
+    private static readonly RETRIEVAL_COST;
+    /**
+     * Create a CompoundIndex.
+     *
+     * @param attributes - Array of attributes to index (order matters!)
+     * @param options - Optional configuration
+     *
+     * @example
+     * ```typescript
+     * const statusAttr = simpleAttribute<Product, string>('status', p => p.status);
+     * const categoryAttr = simpleAttribute<Product, string>('category', p => p.category);
+     *
+     * const compoundIndex = new CompoundIndex<string, Product>([statusAttr, categoryAttr]);
+     * ```
+     */
+    constructor(attributes: Attribute<V, unknown>[], options?: CompoundIndexOptions);
+    /**
+     * Get the first attribute (used for Index interface compatibility).
+     * Note: CompoundIndex spans multiple attributes.
+     */
+    get attribute(): Attribute<V, unknown>;
+    /**
+     * Get all attributes in this compound index.
+     */
+    get attributes(): Attribute<V, unknown>[];
+    /**
+     * Get attribute names as a combined identifier.
+     */
+    get compoundName(): string;
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    /**
+     * Retrieve records matching compound query.
+     *
+     * @param query - Compound query with values matching each attribute
+     * @returns ResultSet of matching keys
+     *
+     * @example
+     * ```typescript
+     * // Find products where status='active' AND category='electronics'
+     * index.retrieve({
+     *   type: 'compound',
+     *   values: ['active', 'electronics']
+     * });
+     * ```
+     */
+    retrieve(query: IndexQuery<unknown>): ResultSet<K>;
+    /**
+     * Retrieve with explicit values (convenience method).
+     *
+     * @param values - Values in order of index attributes
+     * @returns ResultSet of matching keys
+     */
+    retrieveByValues(...values: unknown[]): ResultSet<K>;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Get extended statistics for compound index.
+     */
+    getExtendedStats(): CompoundIndexStats;
+    /**
+     * Check if this compound index can answer a query on the given attributes.
+     * Compound indexes can be used if query attributes match in prefix order.
+     *
+     * @param attributeNames - Attribute names being queried
+     * @returns true if this index can answer the query
+     */
+    canAnswerQuery(attributeNames: string[]): boolean;
+    /**
+     * Build composite key from array of values.
+     */
+    private buildCompositeKey;
+    /**
+     * Build composite key from record by extracting attribute values.
+     * Returns null if any attribute value is undefined.
+     */
+    private buildCompositeKeyFromRecord;
+    /**
+     * Encode value for composite key.
+     * Handles common types and escapes separator.
+     */
+    private encodeValue;
+    /**
+     * Escape regex special characters.
+     */
+    private escapeRegex;
+}
+/**
+ * Extended statistics for compound index.
+ */
+interface CompoundIndexStats extends IndexStats {
+    /** Number of attributes in compound key */
+    attributeCount: number;
+    /** Names of indexed attributes */
+    attributeNames: string[];
+    /** Number of unique composite keys */
+    compositeKeyCount: number;
+}
+
+/**
+ * Types for Adaptive Indexing System (Phase 8.02)
+ *
+ * Defines interfaces for query pattern tracking, index suggestions,
+ * and auto-indexing configuration.
+ *
+ * @module query/adaptive/types
+ */
+/**
+ * Query type for pattern tracking.
+ * Matches the query types from QueryTypes.ts and indexes/types.ts
+ */
+type TrackedQueryType = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'in' | 'has' | 'contains' | 'containsAll' | 'containsAny' | 'compound';
+/**
+ * Statistics for a single attribute + query type combination.
+ */
+interface QueryStatistics {
+    /** Attribute name being queried */
+    attribute: string;
+    /** Type of query (eq, gt, between, etc.) */
+    queryType: TrackedQueryType;
+    /** Number of times this pattern was queried */
+    queryCount: number;
+    /** Cumulative execution time in milliseconds */
+    totalCost: number;
+    /** Average execution time per query */
+    averageCost: number;
+    /** Timestamp of last query */
+    lastQueried: number;
+    /** Estimated result size (max observed) */
+    estimatedCardinality: number;
+    /** Whether an index exists for this attribute */
+    hasIndex: boolean;
+}
+/**
+ * Statistics for compound query patterns (Phase 9.03).
+ * Tracks AND combinations of attributes for compound index suggestions.
+ */
+interface CompoundQueryStatistics {
+    /** Attribute names in the compound query (sorted) */
+    attributes: string[];
+    /** Combined key for identification */
+    compoundKey: string;
+    /** Number of times this pattern was queried */
+    queryCount: number;
+    /** Cumulative execution time in milliseconds */
+    totalCost: number;
+    /** Average execution time per query */
+    averageCost: number;
+    /** Timestamp of last query */
+    lastQueried: number;
+    /** Whether a compound index exists for this combination */
+    hasCompoundIndex: boolean;
+}
+/**
+ * Index type recommendation.
+ */
+type RecommendedIndexType = 'hash' | 'navigable' | 'inverted' | 'compound';
+/**
+ * Priority level for index suggestions.
+ */
+type SuggestionPriority = 'high' | 'medium' | 'low';
+/**
+ * Index suggestion generated by IndexAdvisor.
+ */
+interface IndexSuggestion {
+    /** Attribute to index (or compound key for compound indexes) */
+    attribute: string;
+    /** Recommended index type */
+    indexType: RecommendedIndexType;
+    /** Human-readable explanation */
+    reason: string;
+    /** Expected performance improvement multiplier */
+    estimatedBenefit: number;
+    /** Estimated memory overhead in bytes */
+    estimatedCost: number;
+    /** Priority based on query patterns */
+    priority: SuggestionPriority;
+    /** Query count that triggered this suggestion */
+    queryCount: number;
+    /** Average query cost in milliseconds */
+    averageCost: number;
+    /** For compound indexes: array of attribute names in order */
+    compoundAttributes?: string[];
+}
+/**
+ * Options for getting index suggestions.
+ */
+interface IndexSuggestionOptions {
+    /** Minimum query count to consider (default: 10) */
+    minQueryCount?: number;
+    /** Minimum average cost in ms to consider (default: 1) */
+    minAverageCost?: number;
+    /** Whether to exclude already indexed attributes (default: true) */
+    excludeExistingIndexes?: boolean;
+    /** Maximum number of suggestions to return (default: unlimited) */
+    maxSuggestions?: number;
+}
+/**
+ * Configuration for Index Advisor.
+ */
+interface AdvisorConfig {
+    /** Enable advisor mode (default: true) */
+    enabled: boolean;
+    /** Minimum query count before suggesting (default: 10) */
+    minQueryCount?: number;
+    /** Minimum average cost in ms to suggest (default: 1) */
+    minAverageCost?: number;
+}
+/**
+ * Callback for index creation events.
+ */
+type IndexCreatedCallback = (attribute: string, indexType: RecommendedIndexType) => void;
+/**
+ * Configuration for Auto-Index Manager.
+ */
+interface AutoIndexConfig {
+    /** Enable auto-indexing (default: false) */
+    enabled: boolean;
+    /** Number of queries before auto-creating index (default: 10) */
+    threshold?: number;
+    /** Maximum number of auto-created indexes (default: 20) */
+    maxIndexes?: number;
+    /** Callback when index is automatically created */
+    onIndexCreated?: IndexCreatedCallback;
+}
+/**
+ * Default indexing strategy.
+ * - 'none': No automatic indexing (default)
+ * - 'scalar': Index all top-level scalar (primitive) fields
+ * - 'all': Index all fields including nested (not recommended)
+ */
+type DefaultIndexingStrategy = 'none' | 'scalar' | 'all';
+/**
+ * Complete adaptive indexing configuration.
+ */
+interface AdaptiveIndexingConfig {
+    /** Index Advisor configuration */
+    advisor?: AdvisorConfig;
+    /** Auto-Index Manager configuration */
+    autoIndex?: AutoIndexConfig;
+}
+/**
+ * Progress callback for lazy index building (Phase 9.01).
+ */
+type IndexBuildProgressCallback = (attributeName: string, progress: number, // 0-100
+recordsProcessed: number, totalRecords: number) => void;
+/**
+ * Extended options for IndexedLWWMap/IndexedORMap.
+ */
+interface IndexedMapOptions {
+    /** Adaptive indexing configuration */
+    adaptiveIndexing?: AdaptiveIndexingConfig;
+    /** Default indexing strategy (default: 'none') */
+    defaultIndexing?: DefaultIndexingStrategy;
+    /**
+     * Enable lazy index building (Phase 9.01).
+     * When true, indexes are not built until first query.
+     * Default: false
+     */
+    lazyIndexBuilding?: boolean;
+    /**
+     * Callback for index building progress (Phase 9.01).
+     * Called during lazy index materialization.
+     */
+    onIndexBuilding?: IndexBuildProgressCallback;
+}
+
+/**
+ * Lazy Index Types
+ *
+ * Types and interfaces for lazy index building (Phase 9.01).
+ * Lazy indexes defer actual index construction until first query.
+ *
+ * @module query/indexes/lazy/types
+ */
+
+/**
+ * Extended interface for lazy indexes.
+ * Adds lazy-specific properties and methods.
+ */
+interface LazyIndex<K, V, A = unknown> extends Index<K, V, A> {
+    /**
+     * Whether the index has been materialized (built).
+     */
+    readonly isBuilt: boolean;
+    /**
+     * Number of pending records awaiting materialization.
+     */
+    readonly pendingCount: number;
+    /**
+     * Force materialization of the index.
+     * Called automatically on first query, but can be called manually.
+     *
+     * @param progressCallback - Optional progress callback
+     */
+    materialize(progressCallback?: IndexBuildProgressCallback): void;
+    /**
+     * Check if this is a lazy index wrapper.
+     */
+    readonly isLazy: true;
+}
+/**
+ * Options for lazy index creation.
+ */
+interface LazyIndexOptions {
+    /**
+     * Progress callback for index building.
+     */
+    onProgress?: IndexBuildProgressCallback;
+    /**
+     * Batch size for progress reporting.
+     * Default: 1000
+     */
+    progressBatchSize?: number;
+}
+
+/**
+ * LazyHashIndex Implementation
+ *
+ * Hash-based index with deferred building (Phase 9.01).
+ * Records are buffered until first query, then index is materialized.
+ *
+ * Benefits:
+ * - Fast application startup (indexes built on-demand)
+ * - Memory efficiency (unused indexes not built)
+ * - Bulk import optimization (no index overhead during import)
+ *
+ * @module query/indexes/lazy/LazyHashIndex
+ */
+
+/**
+ * Lazy hash-based index for O(1) equality lookups.
+ * Defers index construction until first query.
+ *
+ * K = record key type, V = record value type, A = attribute value type
+ */
+declare class LazyHashIndex<K, V, A> implements LazyIndex<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    readonly type: "hash";
+    readonly isLazy: true;
+    /** Underlying hash index (created on first query) */
+    private innerIndex;
+    /** Pending records before materialization */
+    private pendingRecords;
+    /** Track if index has been built */
+    private built;
+    /** Progress callback */
+    private readonly onProgress?;
+    /** Batch size for progress reporting */
+    private readonly progressBatchSize;
+    constructor(attribute: Attribute<V, A>, options?: LazyIndexOptions);
+    get isBuilt(): boolean;
+    get pendingCount(): number;
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Force materialization of the index.
+     * Called automatically on first query.
+     */
+    materialize(progressCallback?: IndexBuildProgressCallback): void;
+    /**
+     * Get the underlying HashIndex (for testing/debugging).
+     * Returns null if not yet materialized.
+     */
+    getInnerIndex(): HashIndex<K, V, A> | null;
+}
+
+/**
+ * LazyNavigableIndex Implementation
+ *
+ * Sorted index with deferred building (Phase 9.01).
+ * Records are buffered until first query, then index is materialized.
+ *
+ * Benefits:
+ * - Fast application startup (indexes built on-demand)
+ * - Memory efficiency (unused indexes not built)
+ * - Bulk import optimization (no index overhead during import)
+ *
+ * @module query/indexes/lazy/LazyNavigableIndex
+ */
+
+/**
+ * Lazy sorted index for O(log N) range queries.
+ * Defers index construction until first query.
+ *
+ * K = record key type, V = record value type, A = attribute value type (must be orderable)
+ */
+declare class LazyNavigableIndex<K, V, A extends string | number> implements LazyIndex<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    readonly type: "navigable";
+    readonly isLazy: true;
+    /** Underlying navigable index (created on first query) */
+    private innerIndex;
+    /** Pending records before materialization */
+    private pendingRecords;
+    /** Track if index has been built */
+    private built;
+    /** Custom comparator (stored for later index creation) */
+    private readonly comparator?;
+    /** Progress callback */
+    private readonly onProgress?;
+    /** Batch size for progress reporting */
+    private readonly progressBatchSize;
+    constructor(attribute: Attribute<V, A>, comparator?: Comparator<A>, options?: LazyIndexOptions);
+    get isBuilt(): boolean;
+    get pendingCount(): number;
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Force materialization of the index.
+     * Called automatically on first query.
+     */
+    materialize(progressCallback?: IndexBuildProgressCallback): void;
+    /**
+     * Get the underlying NavigableIndex (for testing/debugging).
+     * Returns null if not yet materialized.
+     */
+    getInnerIndex(): NavigableIndex<K, V, A> | null;
+    /**
+     * Get the minimum indexed value.
+     * Forces materialization if not built.
+     */
+    getMinValue(): A | undefined;
+    /**
+     * Get the maximum indexed value.
+     * Forces materialization if not built.
+     */
+    getMaxValue(): A | undefined;
+}
+
+/**
+ * LazyInvertedIndex Implementation
+ *
+ * Full-text search index with deferred building (Phase 9.01).
+ * Records are buffered until first query, then index is materialized.
+ *
+ * Benefits:
+ * - Fast application startup (indexes built on-demand)
+ * - Memory efficiency (unused indexes not built)
+ * - Bulk import optimization (no index overhead during import)
+ *
+ * @module query/indexes/lazy/LazyInvertedIndex
+ */
+
+/**
+ * Lazy inverted index for full-text search.
+ * Defers index construction until first query.
+ *
+ * K = record key type, V = record value type, A = attribute value type (should be string)
+ */
+declare class LazyInvertedIndex<K, V, A extends string = string> implements LazyIndex<K, V, A> {
+    readonly attribute: Attribute<V, A>;
+    readonly type: "inverted";
+    readonly isLazy: true;
+    /** Underlying inverted index (created on first query) */
+    private innerIndex;
+    /** Pending records before materialization */
+    private pendingRecords;
+    /** Track if index has been built */
+    private built;
+    /** Tokenization pipeline (stored for later index creation) */
+    private readonly pipeline;
+    /** Progress callback */
+    private readonly onProgress?;
+    /** Batch size for progress reporting */
+    private readonly progressBatchSize;
+    constructor(attribute: Attribute<V, A>, pipeline?: TokenizationPipeline, options?: LazyIndexOptions);
+    get isBuilt(): boolean;
+    get pendingCount(): number;
+    getRetrievalCost(): number;
+    supportsQuery(queryType: string): boolean;
+    retrieve(query: IndexQuery<A>): ResultSet<K>;
+    add(key: K, record: V): void;
+    remove(key: K, record: V): void;
+    update(key: K, oldRecord: V, newRecord: V): void;
+    clear(): void;
+    getStats(): IndexStats;
+    /**
+     * Get extended statistics for full-text index.
+     * Forces materialization if not built.
+     */
+    getExtendedStats(): InvertedIndexStats;
+    /**
+     * Force materialization of the index.
+     * Called automatically on first query.
+     */
+    materialize(progressCallback?: IndexBuildProgressCallback): void;
+    /**
+     * Get the underlying InvertedIndex (for testing/debugging).
+     * Returns null if not yet materialized.
+     */
+    getInnerIndex(): InvertedIndex<K, V, A> | null;
+    /**
+     * Get the tokenization pipeline.
+     */
+    getPipeline(): TokenizationPipeline;
+    /**
+     * Check if a specific token exists in the index.
+     * Forces materialization if not built.
+     */
+    hasToken(token: string): boolean;
+    /**
+     * Get the number of documents for a specific token.
+     * Forces materialization if not built.
+     */
+    getTokenDocumentCount(token: string): number;
+}
+
+/**
+ * SetResultSet Implementation
+ *
+ * ResultSet backed by a Set, used for HashIndex results.
+ *
+ * @module query/resultset/SetResultSet
+ */
+
+/**
+ * ResultSet backed by a Set.
+ * Provides O(1) contains() check and direct iteration.
+ */
+declare class SetResultSet<K> implements ResultSet<K> {
+    private readonly keys;
+    private readonly retrievalCost;
+    constructor(keys: Set<K>, retrievalCost: number);
+    [Symbol.iterator](): Iterator<K>;
+    getRetrievalCost(): number;
+    getMergeCost(): number;
+    contains(key: K): boolean;
+    size(): number;
+    toArray(): K[];
+    isEmpty(): boolean;
+}
+
+/**
+ * LazyResultSet Implementation
+ *
+ * Lazily evaluated result set for range queries.
+ * Used when materializing all results upfront would be expensive.
+ *
+ * @module query/resultset/LazyResultSet
+ */
+
+/**
+ * Factory function type that creates a generator for lazy iteration.
+ */
+type IteratorFactory<K> = () => Generator<K>;
+/**
+ * Lazily evaluated result set.
+ * Used for range queries where materializing all results upfront is expensive.
+ *
+ * K = record key type
+ */
+declare class LazyResultSet<K> implements ResultSet<K> {
+    private readonly iteratorFactory;
+    private readonly retrievalCost;
+    private readonly estimatedSize;
+    /** Cached materialized results */
+    private cached;
+    /**
+     * Create a LazyResultSet.
+     *
+     * @param iteratorFactory - Factory that creates a fresh generator each time
+     * @param retrievalCost - Cost of retrieving results from the index
+     * @param estimatedSize - Estimated result count for merge cost calculation
+     */
+    constructor(iteratorFactory: IteratorFactory<K>, retrievalCost: number, estimatedSize: number);
+    [Symbol.iterator](): Generator<K>;
+    getRetrievalCost(): number;
+    getMergeCost(): number;
+    contains(key: K): boolean;
+    size(): number;
+    toArray(): K[];
+    isEmpty(): boolean;
+    /**
+     * Check if the result set has been materialized.
+     * Useful for testing lazy evaluation behavior.
+     */
+    isMaterialized(): boolean;
+    /**
+     * Force materialization of the result set.
+     * Returns the cached array.
+     */
+    materialize(): K[];
+    /**
+     * Get the estimated size before materialization.
+     */
+    getEstimatedSize(): number;
+}
+
+/**
+ * IntersectionResultSet Implementation
+ *
+ * Intersection of multiple result sets (AND logic).
+ * Implements CQEngine "smallest first" strategy:
+ * iterate the smallest set, check membership in others.
+ *
+ * @module query/resultset/IntersectionResultSet
+ */
+
+/**
+ * Intersection of multiple result sets (AND logic).
+ * CQEngine strategy: iterate smallest set, check membership in others.
+ *
+ * K = record key type
+ */
+declare class IntersectionResultSet<K> implements ResultSet<K> {
+    /** Cached materialized results */
+    private cached;
+    /** Result sets sorted by merge cost */
+    private sortedResultSets;
+    /**
+     * Create an IntersectionResultSet.
+     *
+     * @param resultSets - Result sets to intersect
+     */
+    constructor(resultSets: ResultSet<K>[]);
+    /**
+     * Lazy iteration over intersection.
+     * Iterates smallest set, yields only keys present in all sets.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Retrieval cost is minimum of all (we only iterate smallest).
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost is estimated as smallest set size (upper bound).
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in all result sets.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size by materializing results.
+     */
+    size(): number;
+    /**
+     * Materialize to array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty (tries to avoid full materialization).
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+}
+
+/**
+ * UnionResultSet Implementation
+ *
+ * Union of multiple result sets (OR logic).
+ * Deduplicates results using a Set during iteration.
+ *
+ * @module query/resultset/UnionResultSet
+ */
+
+/**
+ * Union of multiple result sets (OR logic).
+ * Deduplicates results.
+ *
+ * K = record key type
+ */
+declare class UnionResultSet<K> implements ResultSet<K> {
+    private readonly resultSets;
+    /** Cached materialized results */
+    private cached;
+    /**
+     * Create a UnionResultSet.
+     *
+     * @param resultSets - Result sets to union
+     */
+    constructor(resultSets: ResultSet<K>[]);
+    /**
+     * Lazy iteration over union with deduplication.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Retrieval cost is sum of all costs.
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost upper bound: sum of all sizes.
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in any result set.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size by materializing results.
+     */
+    size(): number;
+    /**
+     * Materialize to array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty (all sources must be empty).
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+}
+
+/**
+ * FilteringResultSet Implementation
+ *
+ * Filters a source result set with a predicate.
+ * Used when an index is available for part of a query,
+ * but additional filtering is needed.
+ *
+ * @module query/resultset/FilteringResultSet
+ */
+
+/**
+ * Predicate function for filtering records.
+ */
+type PredicateFn<V> = (record: V) => boolean;
+/**
+ * Filters a source result set with a predicate.
+ *
+ * K = record key type, V = record value type
+ */
+declare class FilteringResultSet<K, V> implements ResultSet<K> {
+    private readonly source;
+    private readonly getRecord;
+    private readonly predicate;
+    /** Cached materialized results */
+    private cached;
+    /**
+     * Create a FilteringResultSet.
+     *
+     * @param source - Source result set to filter
+     * @param getRecord - Function to get record by key
+     * @param predicate - Predicate function to filter records
+     */
+    constructor(source: ResultSet<K>, getRecord: (key: K) => V | undefined, predicate: PredicateFn<V>);
+    /**
+     * Lazy iteration with filtering.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Retrieval cost: source cost + filter overhead.
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost: estimate half of source (pessimistic).
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in source and passes predicate.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size by materializing results.
+     */
+    size(): number;
+    /**
+     * Materialize to array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty (tries to find at least one match).
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+}
+
+/**
+ * SortedResultSet Implementation
+ *
+ * ResultSet with sorting support.
+ * If source is from NavigableIndex on sort field, results are already sorted.
+ * Otherwise, performs in-memory sort.
+ *
+ * @module query/resultset/SortedResultSet
+ */
+
+/**
+ * Comparator function for sorting.
+ */
+type CompareFn<V> = (a: V, b: V) => number;
+/**
+ * ResultSet with sorting support.
+ *
+ * K = record key type, V = record value type
+ */
+declare class SortedResultSet<K, V> implements ResultSet<K> {
+    private readonly source;
+    private readonly getRecord;
+    private readonly sortField;
+    private readonly direction;
+    private readonly isPreSorted;
+    /** Cached sorted results */
+    private cached;
+    /**
+     * Create a SortedResultSet.
+     *
+     * @param source - Source result set
+     * @param getRecord - Function to get record by key
+     * @param sortField - Field to sort by
+     * @param direction - Sort direction ('asc' or 'desc')
+     * @param isPreSorted - Whether source is already sorted (from NavigableIndex)
+     */
+    constructor(source: ResultSet<K>, getRecord: (key: K) => V | undefined, sortField: string, direction: 'asc' | 'desc', isPreSorted?: boolean);
+    /**
+     * Lazy iteration with sorting.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Materialize to sorted array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Retrieval cost: source cost + sort overhead.
+     * Pre-sorted has minimal overhead.
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost: same as source (sorting doesn't change size).
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in source.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size (same as source).
+     */
+    size(): number;
+    /**
+     * Check if empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+    /**
+     * Check if this result set is pre-sorted.
+     */
+    isIndexSorted(): boolean;
+    /**
+     * Get sort field.
+     */
+    getSortField(): string;
+    /**
+     * Get sort direction.
+     */
+    getSortDirection(): 'asc' | 'desc';
+}
+/**
+ * Create a comparator function for a field.
+ *
+ * @param field - Field name to compare
+ * @param direction - Sort direction
+ */
+declare function createFieldComparator<V>(field: string, direction: 'asc' | 'desc'): CompareFn<V>;
+
+/**
+ * LimitResultSet Implementation
+ *
+ * Applies offset/limit to source ResultSet.
+ * Implements early termination for efficiency.
+ *
+ * @module query/resultset/LimitResultSet
+ */
+
+/**
+ * Applies offset/limit to source ResultSet.
+ * Implements early termination for efficiency.
+ *
+ * K = record key type
+ */
+declare class LimitResultSet<K> implements ResultSet<K> {
+    private readonly source;
+    private readonly offset;
+    private readonly limit;
+    /** Cached materialized results */
+    private cached;
+    /**
+     * Create a LimitResultSet.
+     *
+     * @param source - Source result set
+     * @param offset - Number of results to skip (default: 0)
+     * @param limit - Maximum number of results (default: Infinity)
+     */
+    constructor(source: ResultSet<K>, offset?: number, limit?: number);
+    /**
+     * Lazy iteration with offset/limit and early termination.
+     */
+    [Symbol.iterator](): Generator<K>;
+    /**
+     * Retrieval cost: source cost (limit doesn't change retrieval cost).
+     */
+    getRetrievalCost(): number;
+    /**
+     * Merge cost: min(source size, offset + limit).
+     */
+    getMergeCost(): number;
+    /**
+     * Check if key is in result (with offset/limit constraints).
+     * This is expensive as it requires iteration to determine position.
+     */
+    contains(key: K): boolean;
+    /**
+     * Get size by materializing results.
+     */
+    size(): number;
+    /**
+     * Materialize to array with caching.
+     */
+    toArray(): K[];
+    /**
+     * Check if empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if results have been materialized.
+     */
+    isMaterialized(): boolean;
+    /**
+     * Get the offset value.
+     */
+    getOffset(): number;
+    /**
+     * Get the limit value.
+     */
+    getLimit(): number;
+}
+
+/**
+ * IndexRegistry Implementation
+ *
+ * Central registry for managing indexes on a collection.
+ * Provides index lookup, lifecycle management, and bulk operations.
+ *
+ * @module query/IndexRegistry
+ */
+
+/**
+ * Registry for managing indexes on a collection.
+ * Provides index lookup and lifecycle management.
+ *
+ * K = record key type, V = record value type
+ */
+declare class IndexRegistry<K, V> {
+    /** Indexes grouped by attribute name */
+    private attributeIndexes;
+    /** Compound indexes (Phase 9.03) - keyed by sorted attribute names */
+    private compoundIndexes;
+    /** Fallback index for full scan (optional) */
+    private fallbackIndex;
+    /**
+     * Register an index for an attribute.
+     * Multiple indexes can be registered for the same attribute.
+     *
+     * @param index - Index to register
+     */
+    addIndex<A>(index: Index<K, V, A>): void;
+    /**
+     * Register a compound index (Phase 9.03).
+     *
+     * @param index - Compound index to register
+     */
+    addCompoundIndex(index: CompoundIndex<K, V>): void;
+    /**
+     * Remove an index from the registry.
+     *
+     * @param index - Index to remove
+     * @returns true if index was found and removed
+     */
+    removeIndex<A>(index: Index<K, V, A>): boolean;
+    /**
+     * Remove a compound index (Phase 9.03).
+     *
+     * @param index - Compound index to remove
+     * @returns true if index was found and removed
+     */
+    removeCompoundIndex(index: CompoundIndex<K, V>): boolean;
+    /**
+     * Get all indexes for an attribute.
+     *
+     * @param attributeName - Attribute name
+     * @returns Array of indexes (empty if none)
+     */
+    getIndexes(attributeName: string): Index<K, V, unknown>[];
+    /**
+     * Get all registered indexes across all attributes.
+     *
+     * @returns Array of all indexes
+     */
+    getAllIndexes(): Index<K, V, unknown>[];
+    /**
+     * Get all indexed attribute names.
+     *
+     * @returns Array of attribute names
+     */
+    getIndexedAttributes(): string[];
+    /**
+     * Check if an attribute has any indexes.
+     *
+     * @param attributeName - Attribute name
+     * @returns true if attribute has indexes
+     */
+    hasIndex(attributeName: string): boolean;
+    /**
+     * Find the best index for a query type on an attribute.
+     * Returns the index with lowest retrieval cost that supports the query type.
+     *
+     * @param attributeName - Attribute name to search on
+     * @param queryType - Query type (e.g., 'equal', 'gt', 'between')
+     * @returns Best matching index or null if none found
+     */
+    findBestIndex(attributeName: string, queryType: string): Index<K, V, unknown> | null;
+    /**
+     * Find all indexes that support a query type on an attribute.
+     *
+     * @param attributeName - Attribute name
+     * @param queryType - Query type
+     * @returns Array of matching indexes sorted by retrieval cost
+     */
+    findIndexes(attributeName: string, queryType: string): Index<K, V, unknown>[];
+    /**
+     * Find a compound index that covers the given attribute names (Phase 9.03).
+     * The compound index must cover ALL the attributes (exact match or superset).
+     *
+     * @param attributeNames - Array of attribute names to search for
+     * @returns Matching compound index or null
+     */
+    findCompoundIndex(attributeNames: string[]): CompoundIndex<K, V> | null;
+    /**
+     * Check if a compound index exists for the given attributes (Phase 9.03).
+     *
+     * @param attributeNames - Array of attribute names
+     * @returns true if a compound index exists
+     */
+    hasCompoundIndex(attributeNames: string[]): boolean;
+    /**
+     * Get all compound indexes (Phase 9.03).
+     *
+     * @returns Array of all compound indexes
+     */
+    getCompoundIndexes(): CompoundIndex<K, V>[];
+    /**
+     * Create a compound key from attribute names (sorted for consistency).
+     */
+    private makeCompoundKey;
+    /**
+     * Set a fallback index for queries without a suitable index.
+     * Typically a FallbackIndex that performs full scan.
+     *
+     * @param fallback - Fallback index
+     */
+    setFallbackIndex(fallback: Index<K, V, unknown>): void;
+    /**
+     * Get the fallback index.
+     *
+     * @returns Fallback index or null if not set
+     */
+    getFallbackIndex(): Index<K, V, unknown> | null;
+    /**
+     * Notify all indexes of a record addition.
+     * Should be called when a new record is added to the collection.
+     *
+     * @param key - Record key
+     * @param record - Record value
+     */
+    onRecordAdded(key: K, record: V): void;
+    /**
+     * Notify all indexes of a record update.
+     * Should be called when a record's value changes.
+     *
+     * @param key - Record key
+     * @param oldRecord - Previous record value
+     * @param newRecord - New record value
+     */
+    onRecordUpdated(key: K, oldRecord: V, newRecord: V): void;
+    /**
+     * Notify all indexes of a record removal.
+     * Should be called when a record is removed from the collection.
+     *
+     * @param key - Record key
+     * @param record - Removed record value
+     */
+    onRecordRemoved(key: K, record: V): void;
+    /**
+     * Clear all indexes.
+     * Does not remove index registrations, only clears their data.
+     */
+    clear(): void;
+    /**
+     * Get total number of registered indexes.
+     */
+    get size(): number;
+    /**
+     * Get statistics about the registry.
+     */
+    getStats(): IndexRegistryStats;
+}
+/**
+ * Statistics about the IndexRegistry.
+ */
+interface IndexRegistryStats {
+    /** Total number of indexes */
+    totalIndexes: number;
+    /** Number of indexed attributes */
+    indexedAttributes: number;
+    /** Number of compound indexes (Phase 9.03) */
+    compoundIndexes?: number;
+    /** Stats for each index */
+    indexes: Array<{
+        attribute: string;
+        type: string;
+        stats: {
+            distinctValues: number;
+            totalEntries: number;
+            avgEntriesPerValue: number;
+        };
+    }>;
+}
+
+/**
+ * StandingQueryRegistry Implementation
+ *
+ * Registry for managing StandingQueryIndexes.
+ * Used by Live Query system to maintain pre-computed results.
+ *
+ * Features:
+ * - Reference counting for shared indexes
+ * - Automatic cleanup when all subscribers unsubscribe
+ * - Efficient update propagation to all indexes
+ *
+ * @module query/StandingQueryRegistry
+ */
+
+/**
+ * Options for creating a StandingQueryRegistry.
+ */
+interface StandingQueryRegistryOptions<K, V> {
+    /** Function to get record by key */
+    getRecord: (key: K) => V | undefined;
+    /** Function to get all entries for building index */
+    getAllEntries: () => Iterable<[K, V]>;
+}
+/**
+ * Statistics about the StandingQueryRegistry.
+ */
+interface StandingQueryRegistryStats {
+    /** Number of registered indexes */
+    indexCount: number;
+    /** Total reference count across all indexes */
+    totalRefCount: number;
+    /** Total number of results across all indexes */
+    totalResults: number;
+}
+/**
+ * Registry for managing StandingQueryIndexes.
+ * Provides reference counting and lifecycle management.
+ *
+ * K = record key type, V = record value type
+ */
+declare class StandingQueryRegistry<K, V> {
+    /** Map from query hash to StandingQueryIndex */
+    private indexes;
+    /** Reference count for each query (multiple subscriptions can use same index) */
+    private refCounts;
+    /** Record accessor */
+    private readonly getRecord;
+    /** All entries accessor (for building index) */
+    private readonly getAllEntries;
+    constructor(options: StandingQueryRegistryOptions<K, V>);
+    /**
+     * Register a standing query.
+     * Creates new index or returns existing if query already registered.
+     * Increments reference count.
+     *
+     * @param query - Query to register
+     * @returns StandingQueryIndex for the query
+     */
+    register(query: Query): StandingQueryIndex<K, V>;
+    /**
+     * Unregister a standing query.
+     * Decrements reference count. Only removes when refcount reaches 0.
+     *
+     * @param query - Query to unregister
+     * @returns true if index was removed, false if still has references
+     */
+    unregister(query: Query): boolean;
+    /**
+     * Get index for a query if registered.
+     *
+     * @param query - Query to look up
+     * @returns StandingQueryIndex or undefined if not registered
+     */
+    getIndex(query: Query): StandingQueryIndex<K, V> | undefined;
+    /**
+     * Get index by hash directly.
+     *
+     * @param hash - Query hash
+     * @returns StandingQueryIndex or undefined if not registered
+     */
+    getIndexByHash(hash: string): StandingQueryIndex<K, V> | undefined;
+    /**
+     * Check if query has a standing index.
+     *
+     * @param query - Query to check
+     * @returns true if index exists
+     */
+    hasIndex(query: Query): boolean;
+    /**
+     * Get reference count for a query.
+     *
+     * @param query - Query to check
+     * @returns Reference count (0 if not registered)
+     */
+    getRefCount(query: Query): number;
+    /**
+     * Notify all indexes of record addition.
+     * Returns map of query hash to change type for affected queries.
+     *
+     * @param key - Record key
+     * @param record - New record value
+     * @returns Map of query hash to change type
+     */
+    onRecordAdded(key: K, record: V): Map<string, StandingQueryChange>;
+    /**
+     * Notify all indexes of record update.
+     * Returns map of query hash to change type for affected queries.
+     *
+     * @param key - Record key
+     * @param oldRecord - Previous record value
+     * @param newRecord - New record value
+     * @returns Map of query hash to change type
+     */
+    onRecordUpdated(key: K, oldRecord: V, newRecord: V): Map<string, StandingQueryChange>;
+    /**
+     * Notify all indexes of record removal.
+     * Returns map of query hash to change type for affected queries.
+     *
+     * @param key - Record key
+     * @param record - Removed record value
+     * @returns Map of query hash to change type
+     */
+    onRecordRemoved(key: K, record: V): Map<string, StandingQueryChange>;
+    /**
+     * Get all registered queries.
+     *
+     * @returns Array of registered queries
+     */
+    getRegisteredQueries(): Query[];
+    /**
+     * Get all query hashes.
+     *
+     * @returns Array of query hashes
+     */
+    getQueryHashes(): string[];
+    /**
+     * Get statistics about the registry.
+     *
+     * @returns Registry statistics
+     */
+    getStats(): StandingQueryRegistryStats;
+    /**
+     * Clear all indexes.
+     */
+    clear(): void;
+    /**
+     * Get number of registered indexes.
+     */
+    get size(): number;
+    /**
+     * Compute hash for a query.
+     * Used as key in indexes map.
+     */
+    hashQuery(query: Query): string;
+}
+
+/**
+ * QueryOptimizer Implementation
+ *
+ * Cost-based query optimizer for the Query Engine.
+ * Selects optimal index and execution strategy for queries.
+ *
+ * Algorithm based on CQEngine CollectionQueryEngine:
+ * - StandingQueryIndex: Check first (lowest cost = 10)
+ * - AND queries: "smallest first" strategy - sort by merge cost, iterate smallest
+ * - OR queries: Union all results with deduplication
+ * - NOT queries: Get all keys, subtract matching keys
+ *
+ * @module query/QueryOptimizer
+ */
+
+/**
+ * Options for creating a QueryOptimizer.
+ */
+interface QueryOptimizerOptions<K, V> {
+    /** Index registry for attribute-based indexes */
+    indexRegistry: IndexRegistry<K, V>;
+    /** Standing query registry for pre-computed queries (optional) */
+    standingQueryRegistry?: StandingQueryRegistry<K, V>;
+}
+/**
+ * Cost-based query optimizer.
+ * Selects optimal index and execution strategy for queries.
+ *
+ * K = record key type, V = record value type
+ */
+declare class QueryOptimizer<K, V> {
+    private readonly indexRegistry;
+    private readonly standingQueryRegistry?;
+    /**
+     * Create a QueryOptimizer.
+     *
+     * @param indexRegistryOrOptions - IndexRegistry or options object
+     * @param standingQueryRegistry - Optional StandingQueryRegistry (deprecated, use options)
+     */
+    constructor(indexRegistryOrOptions: IndexRegistry<K, V> | QueryOptimizerOptions<K, V>, standingQueryRegistry?: StandingQueryRegistry<K, V>);
+    /**
+     * Optimize a query and return an execution plan.
+     *
+     * Optimization order (by cost):
+     * 1. StandingQueryIndex (cost: 10) - pre-computed results
+     * 2. Other indexes via optimizeNode
+     *
+     * @param query - Query to optimize
+     * @returns Query execution plan
+     */
+    optimize(query: Query): QueryPlan;
+    /**
+     * Optimize a query with sort/limit/offset options.
+     *
+     * @param query - Query to optimize
+     * @param options - Query options (sort, limit, offset)
+     * @returns Query execution plan with options
+     */
+    optimizeWithOptions(query: Query, options: QueryOptions): QueryPlan;
+    /**
+     * Optimize a single query node.
+     */
+    private optimizeNode;
+    /**
+     * Optimize a simple (attribute-based) query.
+     */
+    private optimizeSimple;
+    /**
+     * Optimize a logical (AND/OR/NOT) query.
+     */
+    private optimizeLogical;
+    /**
+     * Optimize AND query.
+     * Strategy: Find child with lowest cost, use as base, filter with rest.
+     *
+     * CQEngine "smallest first" strategy:
+     * 1. Check for CompoundIndex covering all eq children (Phase 9.03)
+     * 2. Sort children by merge cost
+     * 3. Use intersection if multiple indexes available
+     * 4. Apply remaining predicates as filters
+     */
+    private optimizeAnd;
+    /**
+     * Try to use a CompoundIndex for an AND query (Phase 9.03).
+     *
+     * Returns a compound index scan step if:
+     * 1. All children are simple 'eq' queries
+     * 2. A CompoundIndex exists covering all queried attributes
+     *
+     * @param children - Children of the AND query
+     * @returns IndexScanStep using CompoundIndex, or null if not applicable
+     */
+    private tryCompoundIndex;
+    /**
+     * Build values array for compound index query in correct attribute order.
+     *
+     * @param compoundIndex - The compound index to use
+     * @param eqQueries - Array of 'eq' queries
+     * @returns Values array in compound index order, or null if mismatch
+     */
+    private buildCompoundValues;
+    /**
+     * Optimize OR query.
+     * Strategy: Union of all child results with deduplication.
+     */
+    private optimizeOr;
+    /**
+     * Optimize NOT query.
+     * Strategy: Get all keys, subtract matching keys.
+     */
+    private optimizeNot;
+    /**
+     * Map query type to index query type.
+     * Some query types have different names in indexes.
+     */
+    private mapQueryType;
+    /**
+     * Build an IndexQuery from a SimpleQueryNode.
+     */
+    private buildIndexQuery;
+    /**
+     * Estimate the execution cost of a plan step.
+     */
+    private estimateCost;
+    /**
+     * Check if a plan step uses any indexes.
+     */
+    private usesIndexes;
+}
+
+/**
+ * LiveQueryManager Implementation
+ *
+ * Manages live query subscriptions using StandingQueryIndexes.
+ * Provides reactive updates when data changes.
+ *
+ * Features:
+ * - Initial results on subscribe
+ * - Delta updates on record changes
+ * - Shared indexes for identical queries
+ * - Automatic cleanup on unsubscribe
+ *
+ * @module query/LiveQueryManager
+ */
+
+/**
+ * Initial results event sent when subscribing.
+ */
+interface LiveQueryInitialEvent<K> {
+    type: 'initial';
+    query: Query;
+    results: K[];
+}
+/**
+ * Delta event sent when data changes.
+ */
+interface LiveQueryDeltaEvent<K, V> {
+    type: 'delta';
+    query: Query;
+    key: K;
+    record: V;
+    change: StandingQueryChange;
+    operation: 'added' | 'updated' | 'removed';
+    newResultCount: number;
+}
+/**
+ * Union type for all live query events.
+ */
+type LiveQueryEvent<K, V> = LiveQueryInitialEvent<K> | LiveQueryDeltaEvent<K, V>;
+/**
+ * Callback for live query events.
+ */
+type LiveQueryCallback<K, V> = (event: LiveQueryEvent<K, V>) => void;
+/**
+ * Options for creating a LiveQueryManager.
+ */
+interface LiveQueryManagerOptions<K, V> {
+    /** Function to get record by key */
+    getRecord: (key: K) => V | undefined;
+    /** Function to get all entries for building index */
+    getAllEntries: () => Iterable<[K, V]>;
+}
+/**
+ * Manages live query subscriptions using StandingQueryIndexes.
+ * Provides reactive updates when data changes.
+ *
+ * K = record key type, V = record value type
+ */
+declare class LiveQueryManager<K, V> {
+    private registry;
+    /** Subscription callbacks by query hash */
+    private subscriptions;
+    constructor(options: LiveQueryManagerOptions<K, V>);
+    /**
+     * Subscribe to a live query.
+     * Sends initial results immediately, then delta updates on changes.
+     *
+     * @param query - Query to subscribe to
+     * @param callback - Callback for query events
+     * @returns Unsubscribe function
+     */
+    subscribe(query: Query, callback: LiveQueryCallback<K, V>): () => void;
+    /**
+     * Get current results for a query (snapshot).
+     * Does not subscribe to updates.
+     *
+     * @param query - Query to execute
+     * @returns Array of matching keys
+     */
+    getResults(query: Query): K[];
+    /**
+     * Check if a query has active subscriptions.
+     *
+     * @param query - Query to check
+     * @returns true if query has subscribers
+     */
+    hasSubscribers(query: Query): boolean;
+    /**
+     * Get subscriber count for a query.
+     *
+     * @param query - Query to check
+     * @returns Number of subscribers
+     */
+    getSubscriberCount(query: Query): number;
+    /**
+     * Notify of record addition.
+     * Triggers subscription callbacks for affected queries.
+     *
+     * @param key - Record key
+     * @param record - New record value
+     */
+    onRecordAdded(key: K, record: V): void;
+    /**
+     * Notify of record update.
+     * Triggers subscription callbacks for affected queries.
+     *
+     * @param key - Record key
+     * @param oldRecord - Previous record value
+     * @param newRecord - New record value
+     */
+    onRecordUpdated(key: K, oldRecord: V, newRecord: V): void;
+    /**
+     * Notify of record removal.
+     * Triggers subscription callbacks for affected queries.
+     *
+     * @param key - Record key
+     * @param record - Removed record value
+     */
+    onRecordRemoved(key: K, record: V): void;
+    /**
+     * Notify subscribers of changes.
+     */
+    private notifySubscribers;
+    /**
+     * Get the underlying registry for direct access.
+     * Useful for testing and debugging.
+     *
+     * @returns StandingQueryRegistry instance
+     */
+    getRegistry(): StandingQueryRegistry<K, V>;
+    /**
+     * Get all active query hashes.
+     *
+     * @returns Array of query hashes with active subscriptions
+     */
+    getActiveQueries(): string[];
+    /**
+     * Get statistics about the manager.
+     *
+     * @returns Statistics object
+     */
+    getStats(): LiveQueryManagerStats;
+    /**
+     * Clear all subscriptions and indexes.
+     */
+    clear(): void;
+}
+/**
+ * Statistics about the LiveQueryManager.
+ */
+interface LiveQueryManagerStats extends StandingQueryRegistryStats {
+    /** Number of active queries with subscribers */
+    activeQueries: number;
+    /** Total number of subscribers across all queries */
+    totalSubscribers: number;
+}
+
+/**
+ * QueryPatternTracker (Phase 8.02.1)
+ *
+ * Collects runtime statistics on query execution patterns.
+ * Used by IndexAdvisor to generate index suggestions.
+ *
+ * Features:
+ * - Tracks query count, cost, and cardinality per attribute
+ * - Low overhead (< 1% of query time)
+ * - Optional sampling for high-throughput scenarios
+ * - Memory-bounded (circular buffer for old stats)
+ *
+ * @module query/adaptive/QueryPatternTracker
+ */
+
+/**
+ * Options for QueryPatternTracker.
+ */
+interface QueryPatternTrackerOptions {
+    /**
+     * Sampling rate: 1 = track all queries, N = track 1 in N queries.
+     * Higher values reduce overhead but decrease accuracy.
+     * Default: 1 (track all)
+     */
+    samplingRate?: number;
+    /**
+     * Maximum number of unique attribute+queryType combinations to track.
+     * Prevents unbounded memory growth.
+     * Default: 1000
+     */
+    maxTrackedPatterns?: number;
+    /**
+     * Time-to-live for statistics in milliseconds.
+     * Statistics older than this are considered stale.
+     * Default: 24 hours
+     */
+    statsTtl?: number;
+}
+/**
+ * QueryPatternTracker collects runtime statistics on query execution.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new QueryPatternTracker();
+ *
+ * // Record queries during execution
+ * tracker.recordQuery('category', 'eq', 5.2, 100, false);
+ * tracker.recordQuery('category', 'eq', 4.8, 100, false);
+ *
+ * // Record compound AND queries (Phase 9.03)
+ * tracker.recordCompoundQuery(['status', 'category'], 10.5, 50, false);
+ *
+ * // Get statistics
+ * const stats = tracker.getStatistics();
+ * // [{ attribute: 'category', queryType: 'eq', queryCount: 2, averageCost: 5.0, ... }]
+ * ```
+ */
+declare class QueryPatternTracker {
+    private stats;
+    private compoundStats;
+    private queryCounter;
+    private readonly samplingRate;
+    private readonly maxTrackedPatterns;
+    private readonly statsTtl;
+    constructor(options?: QueryPatternTrackerOptions);
+    /**
+     * Record a query execution for pattern tracking.
+     *
+     * @param attribute - The attribute being queried
+     * @param queryType - The type of query (eq, gt, between, etc.)
+     * @param executionTime - Query execution time in milliseconds
+     * @param resultSize - Number of results returned
+     * @param hasIndex - Whether an index was used
+     */
+    recordQuery(attribute: string, queryType: TrackedQueryType, executionTime: number, resultSize: number, hasIndex: boolean): void;
+    /**
+     * Record a compound (AND) query execution for pattern tracking (Phase 9.03).
+     *
+     * @param attributes - Array of attribute names being queried together
+     * @param executionTime - Query execution time in milliseconds
+     * @param resultSize - Number of results returned
+     * @param hasCompoundIndex - Whether a compound index was used
+     */
+    recordCompoundQuery(attributes: string[], executionTime: number, resultSize: number, hasCompoundIndex: boolean): void;
+    /**
+     * Get all compound query statistics (Phase 9.03).
+     *
+     * @returns Array of compound query statistics, sorted by query count descending
+     */
+    getCompoundStatistics(): CompoundQueryStatistics[];
+    /**
+     * Get compound statistics for a specific attribute combination.
+     *
+     * @param attributes - Array of attribute names
+     * @returns Compound query statistics or undefined
+     */
+    getCompoundStats(attributes: string[]): CompoundQueryStatistics | undefined;
+    /**
+     * Check if attributes appear in any tracked compound queries.
+     *
+     * @param attribute - The attribute name to check
+     * @returns True if attribute is part of any compound query pattern
+     */
+    isInCompoundPattern(attribute: string): boolean;
+    /**
+     * Update compound index status.
+     *
+     * @param attributes - Array of attribute names
+     * @param hasCompoundIndex - Whether a compound index exists
+     */
+    updateCompoundIndexStatus(attributes: string[], hasCompoundIndex: boolean): void;
+    /**
+     * Get all query statistics.
+     *
+     * @returns Array of query statistics, sorted by query count descending
+     */
+    getStatistics(): QueryStatistics[];
+    /**
+     * Get statistics for a specific attribute.
+     *
+     * @param attribute - The attribute name
+     * @returns Array of query statistics for this attribute
+     */
+    getAttributeStats(attribute: string): QueryStatistics[];
+    /**
+     * Get statistics for a specific attribute and query type.
+     *
+     * @param attribute - The attribute name
+     * @param queryType - The query type
+     * @returns Query statistics or undefined
+     */
+    getStats(attribute: string, queryType: TrackedQueryType): QueryStatistics | undefined;
+    /**
+     * Check if an attribute has been queried.
+     *
+     * @param attribute - The attribute name
+     * @returns True if the attribute has query statistics
+     */
+    hasStats(attribute: string): boolean;
+    /**
+     * Get the total number of queries recorded.
+     *
+     * @returns Total query count across all patterns
+     */
+    getTotalQueryCount(): number;
+    /**
+     * Get the number of unique attribute+queryType patterns tracked.
+     *
+     * @returns Number of unique patterns
+     */
+    getPatternCount(): number;
+    /**
+     * Update index status for an attribute.
+     * Called when an index is added or removed.
+     *
+     * @param attribute - The attribute name
+     * @param hasIndex - Whether an index now exists
+     */
+    updateIndexStatus(attribute: string, hasIndex: boolean): void;
+    /**
+     * Reset query count for an attribute after index creation.
+     * This prevents immediate re-suggestion of the same index.
+     *
+     * @param attribute - The attribute name
+     */
+    resetAttributeStats(attribute: string): void;
+    /**
+     * Clear all statistics.
+     */
+    clear(): void;
+    /**
+     * Get a summary of tracking overhead.
+     *
+     * @returns Tracking overhead info
+     */
+    getTrackingInfo(): {
+        patternsTracked: number;
+        compoundPatternsTracked: number;
+        totalQueries: number;
+        samplingRate: number;
+        memoryEstimate: number;
+    };
+    /**
+     * Evict the oldest (least recently queried) entry.
+     */
+    private evictOldest;
+    /**
+     * Prune stale statistics older than TTL.
+     */
+    private pruneStale;
+    /**
+     * Evict the oldest compound query entry (Phase 9.03).
+     */
+    private evictOldestCompound;
+    /**
+     * Prune stale compound statistics (Phase 9.03).
+     */
+    private pruneStaleCompound;
+}
+
+/**
+ * IndexAdvisor (Phase 8.02.2)
+ *
+ * Analyzes query patterns and generates index suggestions.
+ * Used in production mode to help developers optimize their indexes.
+ *
+ * Features:
+ * - Cost/benefit analysis for index suggestions
+ * - Automatic index type selection based on query type
+ * - Priority-based ranking of suggestions
+ * - Memory cost estimation
+ *
+ * @module query/adaptive/IndexAdvisor
+ */
+
+/**
+ * IndexAdvisor analyzes query patterns and generates index suggestions.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new QueryPatternTracker();
+ * const advisor = new IndexAdvisor(tracker);
+ *
+ * // After application runs...
+ * const suggestions = advisor.getSuggestions();
+ * // [
+ * //   {
+ * //     attribute: 'category',
+ * //     indexType: 'hash',
+ * //     reason: 'Queried 1000× with average cost 5.2ms. Expected 500× speedup.',
+ * //     priority: 'high'
+ * //   }
+ * // ]
+ * ```
+ */
+declare class IndexAdvisor {
+    private readonly tracker;
+    constructor(tracker: QueryPatternTracker);
+    /**
+     * Get index suggestions based on query patterns.
+     *
+     * @param options - Suggestion options
+     * @returns Array of index suggestions sorted by priority
+     */
+    getSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
+    /**
+     * Get a suggestion for a specific attribute.
+     *
+     * @param attribute - The attribute name
+     * @returns Index suggestion or null if not recommended
+     */
+    getSuggestionForAttribute(attribute: string): IndexSuggestion | null;
+    /**
+     * Check if an attribute should be indexed based on patterns.
+     *
+     * @param attribute - The attribute name
+     * @param threshold - Minimum query count threshold
+     * @returns True if attribute should be indexed
+     */
+    shouldIndex(attribute: string, threshold?: number): boolean;
+    /**
+     * Get recommended index type for a query type.
+     *
+     * @param queryType - The query type
+     * @returns Recommended index type or null if not indexable
+     */
+    getRecommendedIndexType(queryType: TrackedQueryType): RecommendedIndexType | null;
+    /**
+     * Group statistics by attribute.
+     */
+    private groupByAttribute;
+    /**
+     * Find the best (most beneficial) pattern for an attribute.
+     */
+    private findBestPattern;
+    /**
+     * Generate a suggestion for a query pattern.
+     */
+    private generateSuggestion;
+    /**
+     * Select appropriate index type based on query type.
+     */
+    private selectIndexType;
+    /**
+     * Count how many query patterns would benefit from an index type.
+     */
+    private countBenefitingPatterns;
+    /**
+     * Estimate performance benefit of adding an index.
+     *
+     * Heuristic based on:
+     * - Full scan vs indexed: typically 100-1000× speedup
+     * - Query frequency amplifies benefit
+     */
+    private estimateBenefit;
+    /**
+     * Estimate memory cost of adding an index.
+     */
+    private estimateMemoryCost;
+    /**
+     * Calculate priority based on query patterns and benefit.
+     */
+    private calculatePriority;
+    /**
+     * Generate human-readable reason for the suggestion.
+     */
+    private generateReason;
+    /**
+     * Get compound index suggestions based on AND query patterns.
+     *
+     * @param options - Suggestion options
+     * @returns Array of compound index suggestions
+     */
+    getCompoundSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
+    /**
+     * Get a suggestion for a specific compound attribute combination.
+     *
+     * @param attributes - Array of attribute names
+     * @returns Compound index suggestion or null if not recommended
+     */
+    getCompoundSuggestionFor(attributes: string[]): IndexSuggestion | null;
+    /**
+     * Check if a compound index should be created for the given attributes.
+     *
+     * @param attributes - Array of attribute names
+     * @param threshold - Minimum query count threshold
+     * @returns True if compound index should be created
+     */
+    shouldCreateCompoundIndex(attributes: string[], threshold?: number): boolean;
+    /**
+     * Generate a suggestion for a compound query pattern.
+     */
+    private generateCompoundSuggestion;
+    /**
+     * Estimate performance benefit of adding a compound index.
+     *
+     * Compound indexes provide significant speedup for AND queries:
+     * - Eliminates intersection operations (100-1000× for each attribute)
+     * - Single O(1) lookup instead of multiple index scans
+     */
+    private estimateCompoundBenefit;
+    /**
+     * Estimate memory cost of adding a compound index.
+     */
+    private estimateCompoundMemoryCost;
+    /**
+     * Calculate priority for compound index suggestion.
+     */
+    private calculateCompoundPriority;
+    /**
+     * Generate human-readable reason for compound index suggestion.
+     */
+    private generateCompoundReason;
+}
+
+/**
+ * AutoIndexManager (Phase 8.02.3)
+ *
+ * Automatically creates indexes based on query patterns.
+ * Intended for development mode to simplify index management.
+ *
+ * Features:
+ * - Automatic index creation after threshold queries
+ * - Safety limits to prevent memory exhaustion
+ * - Callback notifications for index creation events
+ * - Integration with IndexAdvisor for type selection
+ *
+ * @module query/adaptive/AutoIndexManager
+ */
+
+/**
+ * Interface for indexed map operations.
+ * Used to decouple AutoIndexManager from IndexedLWWMap/IndexedORMap.
+ */
+interface IndexableMap<K, V> {
+    /** Get all current indexes */
+    getIndexes(): {
+        attribute: {
+            name: string;
+        };
+        type: string;
+    }[];
+    /** Check if attribute has an index */
+    hasIndexOn(attributeName: string): boolean;
+    /** Add a hash index */
+    addHashIndex<A>(attribute: Attribute<V, A>): void;
+    /** Add a navigable index */
+    addNavigableIndex<A extends string | number>(attribute: Attribute<V, A>): void;
+    /** Add an inverted index */
+    addInvertedIndex<A extends string>(attribute: Attribute<V, A>): void;
+}
+/**
+ * AutoIndexManager automatically creates indexes based on query patterns.
+ *
+ * @example
+ * ```typescript
+ * const manager = new AutoIndexManager(tracker, advisor, {
+ *   enabled: true,
+ *   threshold: 10,
+ *   maxIndexes: 20,
+ *   onIndexCreated: (attr, type) => console.log(`Created ${type} on ${attr}`)
+ * });
+ *
+ * manager.registerAttribute(simpleAttribute('category', p => p.category));
+ * manager.setMap(indexedMap);
+ *
+ * // After 10 queries on 'category', index is auto-created
+ * ```
+ */
+declare class AutoIndexManager<K, V> {
+    private readonly tracker;
+    private readonly advisor;
+    private readonly config;
+    private readonly attributeQueryCounts;
+    private readonly registeredAttributes;
+    private readonly createdIndexes;
+    private map;
+    constructor(tracker: QueryPatternTracker, advisor: IndexAdvisor, config: AutoIndexConfig);
+    /**
+     * Set the indexed map to create indexes on.
+     */
+    setMap(map: IndexableMap<K, V>): void;
+    /**
+     * Register an attribute that can be auto-indexed.
+     *
+     * @param attribute - The attribute to register
+     * @param allowedIndexTypes - Optional list of allowed index types
+     */
+    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
+    /**
+     * Unregister an attribute.
+     *
+     * @param attributeName - Name of attribute to unregister
+     */
+    unregisterAttribute(attributeName: string): void;
+    /**
+     * Check if an attribute is registered.
+     *
+     * @param attributeName - Name of attribute to check
+     * @returns True if attribute is registered
+     */
+    hasAttribute(attributeName: string): boolean;
+    /**
+     * Get a registered attribute.
+     *
+     * @param attributeName - Name of attribute
+     * @returns The attribute or undefined
+     */
+    getAttribute(attributeName: string): Attribute<V, unknown> | undefined;
+    /**
+     * Get all registered attribute names.
+     *
+     * @returns Array of registered attribute names
+     */
+    getRegisteredAttributeNames(): string[];
+    /**
+     * Called when a query is executed. Tracks patterns and triggers auto-indexing.
+     *
+     * @param attribute - The attribute being queried
+     * @param queryType - The type of query
+     */
+    onQueryExecuted(attribute: string, queryType: TrackedQueryType): void;
+    /**
+     * Check if we're at the index limit.
+     *
+     * @returns True if max indexes reached
+     */
+    isAtLimit(): boolean;
+    /**
+     * Get number of auto-created indexes.
+     *
+     * @returns Number of indexes created by this manager
+     */
+    getAutoCreatedIndexCount(): number;
+    /**
+     * Get remaining index capacity.
+     *
+     * @returns Number of indexes that can still be created
+     */
+    getRemainingCapacity(): number;
+    /**
+     * Reset query counts (e.g., after clearing data).
+     */
+    resetCounts(): void;
+    /**
+     * Get current configuration.
+     */
+    getConfig(): Readonly<AutoIndexConfig>;
+    /**
+     * Update configuration at runtime.
+     *
+     * @param updates - Partial config updates
+     */
+    updateConfig(updates: Partial<AutoIndexConfig>): void;
+    /**
+     * Try to create an index for the attribute.
+     */
+    private tryCreateIndex;
+    /**
+     * Create an index on the map.
+     */
+    private createIndex;
+}
+
+/**
+ * IndexedLWWMap Implementation
+ *
+ * LWWMap with index support for O(1) to O(log N) queries.
+ * Wraps LWWMap with indexing capabilities using the Wrapper Pattern.
+ *
+ * Features:
+ * - Hash and Navigable indexes for efficient queries
+ * - Live queries with StandingQueryIndex
+ * - Automatic index updates on CRDT operations
+ * - Cost-based query optimization
+ * - Adaptive indexing with query pattern tracking (Phase 8.02)
+ *
+ * @module IndexedLWWMap
+ */
+
+/**
+ * LWWMap with index support for O(1) to O(log N) queries.
+ *
+ * K = key type (extends string for compatibility)
+ * V = value type
+ */
+declare class IndexedLWWMap<K extends string, V> extends LWWMap<K, V> {
+    private indexRegistry;
+    private standingQueryRegistry;
+    private liveQueryManager;
+    private queryOptimizer;
+    private readonly queryTracker;
+    private readonly indexAdvisor;
+    private readonly autoIndexManager;
+    private readonly defaultIndexingStrategy;
+    private readonly options;
+    constructor(hlc: HLC, options?: IndexedMapOptions);
+    /**
+     * Add a hash index on an attribute.
+     * If lazyIndexBuilding is enabled, creates a LazyHashIndex instead.
+     *
+     * @param attribute - Attribute to index
+     * @returns Created HashIndex (or LazyHashIndex)
+     */
+    addHashIndex<A>(attribute: Attribute<V, A>): HashIndex<K, V, A> | LazyHashIndex<K, V, A>;
+    /**
+     * Add a navigable index on an attribute.
+     * Navigable indexes support range queries (gt, gte, lt, lte, between).
+     * If lazyIndexBuilding is enabled, creates a LazyNavigableIndex instead.
+     *
+     * @param attribute - Attribute to index
+     * @param comparator - Optional custom comparator
+     * @returns Created NavigableIndex (or LazyNavigableIndex)
+     */
+    addNavigableIndex<A extends string | number>(attribute: Attribute<V, A>, comparator?: (a: A, b: A) => number): NavigableIndex<K, V, A> | LazyNavigableIndex<K, V, A>;
+    /**
+     * Add an inverted index for full-text search on an attribute.
+     * Inverted indexes support text search queries (contains, containsAll, containsAny).
+     * If lazyIndexBuilding is enabled, creates a LazyInvertedIndex instead.
+     *
+     * @param attribute - Text attribute to index
+     * @param pipeline - Optional custom tokenization pipeline
+     * @returns Created InvertedIndex (or LazyInvertedIndex)
+     *
+     * @example
+     * ```typescript
+     * const nameAttr = simpleAttribute<Product, string>('name', p => p.name);
+     * products.addInvertedIndex(nameAttr);
+     *
+     * // Search for products containing "wireless"
+     * products.query({ type: 'contains', attribute: 'name', value: 'wireless' });
+     * ```
+     */
+    addInvertedIndex<A extends string = string>(attribute: Attribute<V, A>, pipeline?: TokenizationPipeline): InvertedIndex<K, V, A> | LazyInvertedIndex<K, V, A>;
+    /**
+     * Add a custom index.
+     *
+     * @param index - Index to add
+     */
+    addIndex<A>(index: Index<K, V, A>): void;
+    /**
+     * Remove an index.
+     *
+     * @param index - Index to remove
+     * @returns true if index was found and removed
+     */
+    removeIndex<A>(index: Index<K, V, A>): boolean;
+    /**
+     * Get all indexes.
+     *
+     * @returns Array of all indexes
+     */
+    getIndexes(): Index<K, V, unknown>[];
+    /**
+     * Check if an attribute is indexed.
+     *
+     * @param attributeName - Attribute name
+     * @returns true if attribute has indexes
+     */
+    hasIndexOn(attributeName: string): boolean;
+    /**
+     * Build index from existing data.
+     */
+    private buildIndex;
+    /**
+     * Execute a query using indexes.
+     * Returns lazy ResultSet of matching keys.
+     *
+     * Also tracks query patterns for adaptive indexing (Phase 8.02).
+     *
+     * @param query - Query to execute
+     * @returns ResultSet of matching keys
+     */
+    query(query: Query): ResultSet<K>;
+    /**
+     * Execute a query and return materialized results.
+     * Returns array of [key, value] pairs.
+     *
+     * @param query - Query to execute
+     * @returns Array of [key, value] pairs
+     */
+    queryEntries(query: Query): [K, V][];
+    /**
+     * Execute a query and return matching values.
+     *
+     * @param query - Query to execute
+     * @returns Array of matching values
+     */
+    queryValues(query: Query): V[];
+    /**
+     * Count matching records without materializing results.
+     *
+     * @param query - Query to execute
+     * @returns Number of matching records
+     */
+    count(query: Query): number;
+    /**
+     * Execute plan and return result set.
+     */
+    private executePlan;
+    /**
+     * Perform full scan with predicate evaluation.
+     */
+    private fullScan;
+    /**
+     * Check if record matches predicate.
+     * Converts Query to PredicateNode format for evaluation.
+     */
+    private matchesPredicate;
+    /**
+     * Check if record matches IndexQuery (used by FallbackIndex).
+     * This is a simplified matcher for full scan fallback.
+     */
+    private matchesIndexQuery;
+    /**
+     * Convert Query to PredicateNode format.
+     */
+    private queryToPredicate;
+    /**
+     * Subscribe to a live query.
+     * Callback receives initial results and delta updates.
+     *
+     * @param query - Query to subscribe to
+     * @param callback - Callback for query events
+     * @returns Unsubscribe function
+     */
+    subscribeLiveQuery(query: Query, callback: LiveQueryCallback<K, V>): () => void;
+    /**
+     * Get current live query results (snapshot).
+     *
+     * @param query - Query to execute
+     * @returns Array of matching keys
+     */
+    getLiveQueryResults(query: Query): K[];
+    /**
+     * Check if a query has active subscribers.
+     *
+     * @param query - Query to check
+     * @returns true if query has subscribers
+     */
+    hasLiveQuerySubscribers(query: Query): boolean;
+    /**
+     * Set a value (with index updates).
+     */
+    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
+    /**
+     * Remove a value (with index updates).
+     */
+    remove(key: K): LWWRecord<V>;
+    /**
+     * Merge a remote record (with index updates).
+     */
+    merge(key: K, remote: LWWRecord<V>): boolean;
+    /**
+     * Clear all data (and indexes).
+     */
+    clear(): void;
+    /**
+     * Returns all keys (non-tombstoned, non-expired).
+     */
+    keys(): Iterable<K>;
+    /**
+     * Get index statistics.
+     */
+    getIndexStats(): Map<string, IndexStats>;
+    /**
+     * Get index registry statistics.
+     */
+    getIndexRegistryStats(): IndexRegistryStats;
+    /**
+     * Get query optimizer for plan inspection.
+     */
+    getQueryOptimizer(): QueryOptimizer<K, V>;
+    /**
+     * Get live query manager for direct access.
+     */
+    getLiveQueryManager(): LiveQueryManager<K, V>;
+    /**
+     * Get standing query registry for direct access.
+     */
+    getStandingQueryRegistry(): StandingQueryRegistry<K, V>;
+    /**
+     * Explain query execution plan.
+     *
+     * @param query - Query to explain
+     * @returns Query execution plan
+     */
+    explainQuery(query: Query): QueryPlan;
+    /**
+     * Register an attribute for auto-indexing.
+     * Required before auto-index can create indexes on this attribute.
+     *
+     * @param attribute - The attribute to register
+     * @param allowedIndexTypes - Optional list of allowed index types
+     */
+    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
+    /**
+     * Unregister an attribute from auto-indexing.
+     *
+     * @param attributeName - Name of attribute to unregister
+     */
+    unregisterAttribute(attributeName: string): void;
+    /**
+     * Get index suggestions based on query patterns.
+     * Use this in production to get recommendations for manual index creation.
+     *
+     * @param options - Suggestion options
+     * @returns Array of index suggestions sorted by priority
+     *
+     * @example
+     * ```typescript
+     * const suggestions = products.getIndexSuggestions();
+     * // [{ attribute: 'category', indexType: 'hash', priority: 'high', ... }]
+     * ```
+     */
+    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
+    /**
+     * Get query pattern statistics.
+     * Useful for debugging and understanding query patterns.
+     *
+     * @returns Array of query statistics
+     */
+    getQueryStatistics(): QueryStatistics[];
+    /**
+     * Reset query statistics.
+     * Call this to clear accumulated query patterns.
+     */
+    resetQueryStatistics(): void;
+    /**
+     * Get query pattern tracker for advanced usage.
+     */
+    getQueryTracker(): QueryPatternTracker;
+    /**
+     * Get index advisor for advanced usage.
+     */
+    getIndexAdvisor(): IndexAdvisor;
+    /**
+     * Get auto-index manager (if enabled).
+     */
+    getAutoIndexManager(): AutoIndexManager<K, V> | null;
+    /**
+     * Check if auto-indexing is enabled.
+     */
+    isAutoIndexingEnabled(): boolean;
+    /**
+     * Check if lazy index building is enabled.
+     */
+    isLazyIndexingEnabled(): boolean;
+    /**
+     * Force materialization of all lazy indexes.
+     * Useful to pre-warm indexes before critical operations.
+     *
+     * @param progressCallback - Optional progress callback
+     */
+    materializeAllIndexes(progressCallback?: IndexBuildProgressCallback): void;
+    /**
+     * Get count of pending records across all lazy indexes.
+     * Returns 0 if no lazy indexes or all are materialized.
+     */
+    getPendingIndexCount(): number;
+    /**
+     * Check if any lazy indexes are still pending (not built).
+     */
+    hasUnbuiltIndexes(): boolean;
+    /**
+     * Track query pattern for adaptive indexing.
+     */
+    private trackQueryPattern;
+    /**
+     * Extract attribute name from query.
+     */
+    private extractAttribute;
+    /**
+     * Extract query type from query.
+     */
+    private extractQueryType;
+}
+
+/**
+ * IndexedORMap Implementation
+ *
+ * ORMap with index support for O(1) to O(log N) queries.
+ * Wraps ORMap with indexing capabilities using the Wrapper Pattern.
+ *
+ * Note: ORMap stores multiple values per key (with tags).
+ * Indexes track unique (key, tag) composite keys.
+ *
+ * Features:
+ * - Hash and Navigable indexes for efficient queries
+ * - Composite key indexing (key:tag)
+ * - Automatic index updates on CRDT operations
+ * - Lazy filtering for tombstones
+ * - Adaptive indexing with query pattern tracking (Phase 8.02)
+ *
+ * @module IndexedORMap
+ */
+
+/**
+ * Result of a query on IndexedORMap.
+ */
+interface ORMapQueryResult<K, V> {
+    key: K;
+    tag: string;
+    value: V;
+}
+/**
+ * ORMap with index support.
+ *
+ * Note: ORMap stores multiple values per key (with tags).
+ * Indexes track unique (key, tag) pairs using composite keys.
+ *
+ * K = key type (extends string for compatibility)
+ * V = value type
+ */
+declare class IndexedORMap<K extends string, V> extends ORMap<K, V> {
+    private indexRegistry;
+    private queryOptimizer;
+    private readonly queryTracker;
+    private readonly indexAdvisor;
+    private readonly autoIndexManager;
+    private readonly defaultIndexingStrategy;
+    private readonly options;
+    constructor(hlc: HLC, options?: IndexedMapOptions);
+    /**
+     * Add a hash index on an attribute.
+     *
+     * @param attribute - Attribute to index
+     * @returns Created HashIndex
+     */
+    addHashIndex<A>(attribute: Attribute<V, A>): HashIndex<string, V, A>;
+    /**
+     * Add a navigable index on an attribute.
+     * Navigable indexes support range queries (gt, gte, lt, lte, between).
+     *
+     * @param attribute - Attribute to index
+     * @param comparator - Optional custom comparator
+     * @returns Created NavigableIndex
+     */
+    addNavigableIndex<A extends string | number>(attribute: Attribute<V, A>, comparator?: (a: A, b: A) => number): NavigableIndex<string, V, A>;
+    /**
+     * Add an inverted index for full-text search on an attribute.
+     * Inverted indexes support text search queries (contains, containsAll, containsAny).
+     *
+     * @param attribute - Text attribute to index
+     * @param pipeline - Optional custom tokenization pipeline
+     * @returns Created InvertedIndex
+     */
+    addInvertedIndex<A extends string = string>(attribute: Attribute<V, A>, pipeline?: TokenizationPipeline): InvertedIndex<string, V, A>;
+    /**
+     * Add a custom index.
+     *
+     * @param index - Index to add
+     */
+    addIndex<A>(index: Index<string, V, A>): void;
+    /**
+     * Remove an index.
+     *
+     * @param index - Index to remove
+     * @returns true if index was found and removed
+     */
+    removeIndex<A>(index: Index<string, V, A>): boolean;
+    /**
+     * Get all indexes.
+     *
+     * @returns Array of all indexes
+     */
+    getIndexes(): Index<string, V, unknown>[];
+    /**
+     * Check if an attribute is indexed.
+     *
+     * @param attributeName - Attribute name
+     * @returns true if attribute has indexes
+     */
+    hasIndexOn(attributeName: string): boolean;
+    /**
+     * Build index from existing data.
+     */
+    private buildIndexFromExisting;
+    /**
+     * Execute a query across all records.
+     * Returns array of matching results with key, tag, and value.
+     *
+     * Also tracks query patterns for adaptive indexing (Phase 8.02).
+     *
+     * @param query - Query to execute
+     * @returns Array of query results
+     */
+    query(query: Query): ORMapQueryResult<K, V>[];
+    /**
+     * Execute a query and return matching values only.
+     *
+     * @param query - Query to execute
+     * @returns Array of matching values
+     */
+    queryValues(query: Query): V[];
+    /**
+     * Count matching records without materializing results.
+     *
+     * @param query - Query to execute
+     * @returns Number of matching records
+     */
+    count(query: Query): number;
+    /**
+     * Execute plan and return result set.
+     */
+    private executePlan;
+    /**
+     * Perform full scan with predicate evaluation.
+     */
+    private fullScan;
+    /**
+     * Add a value (with index updates).
+     */
+    add(key: K, value: V, ttlMs?: number): ORMapRecord<V>;
+    /**
+     * Remove a value (with index updates).
+     */
+    remove(key: K, value: V): string[];
+    /**
+     * Apply a record from remote (with index updates).
+     */
+    apply(key: K, record: ORMapRecord<V>): boolean;
+    /**
+     * Apply a tombstone (with index updates).
+     */
+    applyTombstone(tag: string): void;
+    /**
+     * Clear all data (and indexes).
+     */
+    clear(): void;
+    /**
+     * Create composite key from map key and tag.
+     * Uses '||' as separator since HLC tags contain ':'
+     */
+    private createCompositeKey;
+    /**
+     * Parse composite key into [key, tag].
+     * Expects '||' separator.
+     */
+    private parseCompositeKey;
+    /**
+     * Get all composite keys from the map.
+     */
+    private getAllCompositeKeys;
+    /**
+     * Get record by composite key.
+     */
+    private getRecordByCompositeKey;
+    /**
+     * Check if record matches predicate.
+     */
+    private matchesPredicate;
+    /**
+     * Check if record matches IndexQuery (used by FallbackIndex).
+     * This is a simplified matcher for full scan fallback.
+     */
+    private matchesIndexQuery;
+    /**
+     * Convert Query to PredicateNode format.
+     */
+    private queryToPredicate;
+    /**
+     * Get index statistics.
+     */
+    getIndexStats(): Map<string, IndexStats>;
+    /**
+     * Get index registry statistics.
+     */
+    getIndexRegistryStats(): IndexRegistryStats;
+    /**
+     * Get query optimizer for plan inspection.
+     */
+    getQueryOptimizer(): QueryOptimizer<string, V>;
+    /**
+     * Explain query execution plan.
+     *
+     * @param query - Query to explain
+     * @returns Query execution plan
+     */
+    explainQuery(query: Query): QueryPlan;
+    /**
+     * Register an attribute for auto-indexing.
+     * Required before auto-index can create indexes on this attribute.
+     *
+     * @param attribute - The attribute to register
+     * @param allowedIndexTypes - Optional list of allowed index types
+     */
+    registerAttribute<A>(attribute: Attribute<V, A>, allowedIndexTypes?: RecommendedIndexType[]): void;
+    /**
+     * Unregister an attribute from auto-indexing.
+     *
+     * @param attributeName - Name of attribute to unregister
+     */
+    unregisterAttribute(attributeName: string): void;
+    /**
+     * Get index suggestions based on query patterns.
+     * Use this in production to get recommendations for manual index creation.
+     *
+     * @param options - Suggestion options
+     * @returns Array of index suggestions sorted by priority
+     */
+    getIndexSuggestions(options?: IndexSuggestionOptions): IndexSuggestion[];
+    /**
+     * Get query pattern statistics.
+     * Useful for debugging and understanding query patterns.
+     *
+     * @returns Array of query statistics
+     */
+    getQueryStatistics(): QueryStatistics[];
+    /**
+     * Reset query statistics.
+     * Call this to clear accumulated query patterns.
+     */
+    resetQueryStatistics(): void;
+    /**
+     * Get query pattern tracker for advanced usage.
+     */
+    getQueryTracker(): QueryPatternTracker;
+    /**
+     * Get index advisor for advanced usage.
+     */
+    getIndexAdvisor(): IndexAdvisor;
+    /**
+     * Get auto-index manager (if enabled).
+     */
+    getAutoIndexManager(): AutoIndexManager<string, V> | null;
+    /**
+     * Check if auto-indexing is enabled.
+     */
+    isAutoIndexingEnabled(): boolean;
+    /**
+     * Track query pattern for adaptive indexing.
+     */
+    private trackQueryPattern;
+    /**
+     * Extract attribute name from query.
+     */
+    private extractAttribute;
+    /**
+     * Extract query type from query.
+     */
+    private extractQueryType;
+}
+
+export { type Attribute, AuthMessageSchema, type BatchMessage, BatchMessageSchema, BuiltInProcessors, BuiltInResolvers, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type CompareFn, type ConflictResolver, type ConflictResolverDef, ConflictResolverDefSchema, type ConflictResolverFn, ConflictResolverSchema, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, CounterRequestSchema, CounterResponseSchema, CounterSyncSchema, CounterUpdateSchema, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_EVENT_JOURNAL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_PROCESSOR_RATE_LIMITS, DEFAULT_REPLICATION_CONFIG, DEFAULT_RESOLVER_RATE_LIMITS, DEFAULT_STOP_WORDS, DEFAULT_WRITE_CONCERN_TIMEOUT, type EntryProcessBatchRequest, EntryProcessBatchRequestSchema, type EntryProcessBatchResponse, EntryProcessBatchResponseSchema, type EntryProcessKeyResult, EntryProcessKeyResultSchema, type EntryProcessRequest, EntryProcessRequestSchema, type EntryProcessResponse, EntryProcessResponseSchema, type EntryProcessorDef, EntryProcessorDefSchema, type EntryProcessorFn, type EntryProcessorResult, EntryProcessorSchema, type EventJournal, type EventJournalConfig, EventJournalImpl, FORBIDDEN_PATTERNS, FallbackIndex, type FilterStep, FilteringResultSet, type FullScanStep, HLC, HashIndex, type Index, type IndexQuery, IndexRegistry, type IndexRegistryStats, type IndexScanStep, type IndexStats, IndexedLWWMap, IndexedORMap, IntersectionResultSet, type IntersectionStep, InvertedIndex, type InvertedIndexStats, type IteratorFactory, type JournalEvent, type JournalEventData, JournalEventDataSchema, type JournalEventInput, type JournalEventListener, type JournalEventMessage, JournalEventMessageSchema, type JournalEventType, JournalEventTypeSchema, type JournalReadRequest, JournalReadRequestSchema, type JournalReadResponse, JournalReadResponseSchema, type JournalSubscribeRequest, JournalSubscribeRequestSchema, type JournalUnsubscribeRequest, JournalUnsubscribeRequestSchema, LWWMap, type LWWRecord, LWWRecordSchema, LazyResultSet, LimitResultSet, type ListResolversRequest, ListResolversRequestSchema, type ListResolversResponse, ListResolversResponseSchema, type LiveQueryCallback, type LiveQueryDeltaEvent, type LiveQueryEvent, type LiveQueryInitialEvent, LiveQueryManager, type LiveQueryManagerOptions, type LiveQueryManagerStats, LockReleaseSchema, LockRequestSchema, type LogicalQueryNode, LowercaseFilter, MaxLengthFilter, type MergeContext, type MergeKeyResult, type MergeRejectedMessage, MergeRejectedMessageSchema, type MergeRejection, type MergeResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, MinLengthFilter, MultiValueAttribute, NGramTokenizer, NavigableIndex, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, type NotStep, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapQueryResult, type ORMapRecord, ORMapRecordSchema, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PNCounter, type PNCounterConfig, PNCounterImpl, type PNCounterState, type PNCounterStateObject, PNCounterStateObjectSchema, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PlanStep, type PongMessage, PongMessageSchema, type PredicateFn, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type ProcessorRateLimitConfig, type Query$1 as Query, type Query as QueryExpression, type QueryNode, QueryOptimizer, type QueryOptimizerOptions, type QueryOptions, type QueryPlan, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, RESOLVER_FORBIDDEN_PATTERNS, type RegisterResolverRequest, RegisterResolverRequestSchema, type RegisterResolverResponse, RegisterResolverResponseSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type ResolverRateLimitConfig, type ResultSet, Ringbuffer, type RoutingError, SetResultSet, SimpleAttribute, type SimpleQueryNode, SortedMap, SortedResultSet, type StaleMapError, type StandingQueryChange, StandingQueryIndex, type StandingQueryIndexOptions, StandingQueryRegistry, type StandingQueryRegistryOptions, type StandingQueryRegistryStats, StopWordFilter, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type Timestamp, TimestampSchema, type TokenFilter, TokenizationPipeline, type TokenizationPipelineOptions, type Tokenizer, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, TrimFilter, UnionResultSet, type UnionStep, UniqueFilter, type UnregisterResolverRequest, UnregisterResolverRequestSchema, type UnregisterResolverResponse, UnregisterResolverResponseSchema, WRITE_CONCERN_ORDER, WhitespaceTokenizer, WordBoundaryTokenizer, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareHLCTimestamps, compareTimestamps, createFieldComparator, createPredicateMatcher, deepMerge, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isLogicalQuery, isSimpleQuery, isUsingNativeHash, isWriteConcernAchieved, multiAttribute, resetNativeHash, serialize, simpleAttribute, timestampToString, validateProcessorCode, validateResolverCode };