@push.rocks/smartdb 1.0.1

package/.smartconfig.json

@@ -0,0 +1,38 @@
+{
+  "@git.zone/cli": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartdb",
+      "description": "A pure TypeScript MongoDB wire-protocol-compatible database server with pluggable storage, indexing, transactions, and zero external binary dependencies.",
+      "npmPackagename": "@push.rocks/smartdb",
+      "license": "MIT",
+      "projectDomain": "push.rocks",
+      "keywords": [
+        "mongodb",
+        "wire protocol",
+        "typescript database",
+        "in-memory database",
+        "testing",
+        "local database",
+        "database server",
+        "typescript"
+      ]
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
+    },
+    "services": []
+  },
+  "@git.zone/tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
+  }
+}

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartdb',
+    version: '1.0.1',
+    description: 'A pure TypeScript MongoDB wire-protocol-compatible database server with pluggable storage, indexing, transactions, and zero external binary dependencies.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDJKQUEySjtDQUN6SyxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,5 @@
+import { commitinfo } from './00_commitinfo_data.js';
+export * from './ts_smartdb/index.js';
+export { LocalSmartDb } from './ts_local/index.js';
+export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './ts_local/index.js';
+export { commitinfo };

package/dist_ts/index.js

@@ -0,0 +1,8 @@
+import { commitinfo } from './00_commitinfo_data.js';
+// Export core SmartDB module
+export * from './ts_smartdb/index.js';
+// Export LocalSmartDb
+export { LocalSmartDb } from './ts_local/index.js';
+// Export commitinfo
+export { commitinfo };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUduRCxvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts/ts_local/classes.localsmartdb.d.ts

@@ -0,0 +1,78 @@
+import { SmartdbServer } from '../ts_smartdb/index.js';
+/**
+ * Connection information returned by LocalSmartDb.start()
+ */
+export interface ILocalSmartDbConnectionInfo {
+    /** The Unix socket file path */
+    socketPath: string;
+    /** MongoDB connection URI ready for MongoClient */
+    connectionUri: string;
+}
+export interface ILocalSmartDbOptions {
+    /** Required: where to store data */
+    folderPath: string;
+    /** Optional: custom socket path (default: auto-generated in /tmp) */
+    socketPath?: string;
+}
+/**
+ * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
+ *
+ * This class wraps SmartdbServer and provides a simple interface for
+ * starting a local file-based MongoDB-compatible server. Returns connection
+ * info that you can use with your own MongoDB driver instance.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSmartDb } from '@push.rocks/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const db = new LocalSmartDb({ folderPath: './data' });
+ * const { connectionUri } = await db.start();
+ *
+ * // Connect with your own MongoDB client
+ * const client = new MongoClient(connectionUri, { directConnection: true });
+ * await client.connect();
+ *
+ * // Use the MongoDB client
+ * const collection = client.db('mydb').collection('users');
+ * await collection.insertOne({ name: 'Alice' });
+ *
+ * // When done
+ * await client.close();
+ * await db.stop();
+ * ```
+ */
+export declare class LocalSmartDb {
+    private options;
+    private server;
+    private generatedSocketPath;
+    constructor(options: ILocalSmartDbOptions);
+    /**
+     * Generate a unique socket path in /tmp
+     */
+    private generateSocketPath;
+    /**
+     * Start the local SmartDB server and return connection info
+     */
+    start(): Promise<ILocalSmartDbConnectionInfo>;
+    /**
+     * Get connection info (throws if not started)
+     */
+    getConnectionInfo(): ILocalSmartDbConnectionInfo;
+    /**
+     * Get the underlying SmartdbServer instance (throws if not started)
+     */
+    getServer(): SmartdbServer;
+    /**
+     * Get the connection URI
+     */
+    getConnectionUri(): string;
+    /**
+     * Check if the server is running
+     */
+    get running(): boolean;
+    /**
+     * Stop the local SmartDB server
+     */
+    stop(): Promise<void>;
+}

package/dist_ts/ts_local/classes.localsmartdb.js

@@ -0,0 +1,115 @@
+import * as plugins from './plugins.js';
+import * as crypto from 'crypto';
+import * as path from 'path';
+import * as os from 'os';
+import { SmartdbServer } from '../ts_smartdb/index.js';
+/**
+ * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
+ *
+ * This class wraps SmartdbServer and provides a simple interface for
+ * starting a local file-based MongoDB-compatible server. Returns connection
+ * info that you can use with your own MongoDB driver instance.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSmartDb } from '@push.rocks/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const db = new LocalSmartDb({ folderPath: './data' });
+ * const { connectionUri } = await db.start();
+ *
+ * // Connect with your own MongoDB client
+ * const client = new MongoClient(connectionUri, { directConnection: true });
+ * await client.connect();
+ *
+ * // Use the MongoDB client
+ * const collection = client.db('mydb').collection('users');
+ * await collection.insertOne({ name: 'Alice' });
+ *
+ * // When done
+ * await client.close();
+ * await db.stop();
+ * ```
+ */
+export class LocalSmartDb {
+    options;
+    server = null;
+    generatedSocketPath = null;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Generate a unique socket path in /tmp
+     */
+    generateSocketPath() {
+        const randomId = crypto.randomBytes(8).toString('hex');
+        return path.join(os.tmpdir(), `smartdb-${randomId}.sock`);
+    }
+    /**
+     * Start the local SmartDB server and return connection info
+     */
+    async start() {
+        if (this.server) {
+            throw new Error('LocalSmartDb is already running');
+        }
+        // Use provided socket path or generate one
+        this.generatedSocketPath = this.options.socketPath ?? this.generateSocketPath();
+        this.server = new SmartdbServer({
+            socketPath: this.generatedSocketPath,
+            storage: 'file',
+            storagePath: this.options.folderPath,
+        });
+        await this.server.start();
+        return {
+            socketPath: this.generatedSocketPath,
+            connectionUri: this.server.getConnectionUri(),
+        };
+    }
+    /**
+     * Get connection info (throws if not started)
+     */
+    getConnectionInfo() {
+        if (!this.server || !this.generatedSocketPath) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return {
+            socketPath: this.generatedSocketPath,
+            connectionUri: this.server.getConnectionUri(),
+        };
+    }
+    /**
+     * Get the underlying SmartdbServer instance (throws if not started)
+     */
+    getServer() {
+        if (!this.server) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return this.server;
+    }
+    /**
+     * Get the connection URI
+     */
+    getConnectionUri() {
+        if (!this.server) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return this.server.getConnectionUri();
+    }
+    /**
+     * Check if the server is running
+     */
+    get running() {
+        return this.server !== null && this.server.running;
+    }
+    /**
+     * Stop the local SmartDB server
+     */
+    async stop() {
+        if (this.server) {
+            await this.server.stop();
+            this.server = null;
+            this.generatedSocketPath = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_local/index.d.ts

@@ -0,0 +1,2 @@
+export { LocalSmartDb } from './classes.localsmartdb.js';
+export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './classes.localsmartdb.js';

package/dist_ts/ts_local/index.js

@@ -0,0 +1,2 @@
+export { LocalSmartDb } from './classes.localsmartdb.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19sb2NhbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUMifQ==

package/dist_ts/ts_local/plugins.d.ts

@@ -0,0 +1,2 @@
+import * as smartpromise from '@push.rocks/smartpromise';
+export { smartpromise };

package/dist_ts/ts_local/plugins.js

@@ -0,0 +1,3 @@
+import * as smartpromise from '@push.rocks/smartpromise';
+export { smartpromise };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzX2xvY2FsL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLENBQUMifQ==

package/dist_ts/ts_smartdb/engine/AggregationEngine.d.ts

@@ -0,0 +1,66 @@
+import type { Document, IStoredDocument, IAggregateOptions } from '../types/interfaces.js';
+/**
+ * Aggregation engine using mingo for MongoDB-compatible aggregation pipeline execution
+ */
+export declare class AggregationEngine {
+    /**
+     * Execute an aggregation pipeline on a collection of documents
+     */
+    static aggregate(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Document[];
+    /**
+     * Execute aggregation and return an iterator for lazy evaluation
+     */
+    static aggregateIterator(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Generator<Document>;
+    /**
+     * Execute a $lookup stage manually (for cross-collection lookups)
+     * This is used when the lookup references another collection in the same database
+     */
+    static executeLookup(documents: IStoredDocument[], lookupSpec: {
+        from: string;
+        localField: string;
+        foreignField: string;
+        as: string;
+    }, foreignCollection: IStoredDocument[]): Document[];
+    /**
+     * Execute a $graphLookup stage manually
+     */
+    static executeGraphLookup(documents: IStoredDocument[], graphLookupSpec: {
+        from: string;
+        startWith: string | Document;
+        connectFromField: string;
+        connectToField: string;
+        as: string;
+        maxDepth?: number;
+        depthField?: string;
+        restrictSearchWithMatch?: Document;
+    }, foreignCollection: IStoredDocument[]): Document[];
+    /**
+     * Execute a $facet stage manually
+     */
+    static executeFacet(documents: IStoredDocument[], facetSpec: Record<string, Document[]>): Document;
+    /**
+     * Execute a $unionWith stage
+     */
+    static executeUnionWith(documents: IStoredDocument[], otherDocuments: IStoredDocument[], pipeline?: Document[]): Document[];
+    /**
+     * Execute a $merge stage (output to another collection)
+     * Returns the documents that would be inserted/updated
+     */
+    static prepareMerge(documents: Document[], mergeSpec: {
+        into: string;
+        on?: string | string[];
+        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Document[];
+        whenNotMatched?: 'insert' | 'discard' | 'fail';
+    }): {
+        toInsert: Document[];
+        toUpdate: Array<{
+            filter: Document;
+            update: Document;
+        }>;
+        onField: string | string[];
+        whenMatched: string | Document[];
+        whenNotMatched: string;
+    };
+    private static getNestedValue;
+    private static valuesMatch;
+}

package/dist_ts/ts_smartdb/engine/AggregationEngine.js

@@ -0,0 +1,189 @@
+import * as plugins from '../plugins.js';
+// Import mingo Aggregator
+import { Aggregator } from 'mingo';
+/**
+ * Aggregation engine using mingo for MongoDB-compatible aggregation pipeline execution
+ */
+export class AggregationEngine {
+    /**
+     * Execute an aggregation pipeline on a collection of documents
+     */
+    static aggregate(documents, pipeline, options) {
+        if (!pipeline || pipeline.length === 0) {
+            return documents;
+        }
+        // Create mingo aggregator with the pipeline
+        const aggregator = new Aggregator(pipeline, {
+            collation: options?.collation,
+        });
+        // Run the aggregation
+        const result = aggregator.run(documents);
+        return Array.isArray(result) ? result : [];
+    }
+    /**
+     * Execute aggregation and return an iterator for lazy evaluation
+     */
+    static *aggregateIterator(documents, pipeline, options) {
+        const aggregator = new Aggregator(pipeline, {
+            collation: options?.collation,
+        });
+        // Get the cursor from mingo
+        const cursor = aggregator.stream(documents);
+        for (const doc of cursor) {
+            yield doc;
+        }
+    }
+    /**
+     * Execute a $lookup stage manually (for cross-collection lookups)
+     * This is used when the lookup references another collection in the same database
+     */
+    static executeLookup(documents, lookupSpec, foreignCollection) {
+        const { localField, foreignField, as } = lookupSpec;
+        return documents.map(doc => {
+            const localValue = this.getNestedValue(doc, localField);
+            const matches = foreignCollection.filter(foreignDoc => {
+                const foreignValue = this.getNestedValue(foreignDoc, foreignField);
+                return this.valuesMatch(localValue, foreignValue);
+            });
+            return {
+                ...doc,
+                [as]: matches,
+            };
+        });
+    }
+    /**
+     * Execute a $graphLookup stage manually
+     */
+    static executeGraphLookup(documents, graphLookupSpec, foreignCollection) {
+        const { startWith, connectFromField, connectToField, as, maxDepth = 10, depthField, restrictSearchWithMatch, } = graphLookupSpec;
+        return documents.map(doc => {
+            const startValue = typeof startWith === 'string' && startWith.startsWith('$')
+                ? this.getNestedValue(doc, startWith.slice(1))
+                : startWith;
+            const results = [];
+            const visited = new Set();
+            const queue = [];
+            // Initialize with start value(s)
+            const startValues = Array.isArray(startValue) ? startValue : [startValue];
+            for (const val of startValues) {
+                queue.push({ value: val, depth: 0 });
+            }
+            while (queue.length > 0) {
+                const { value, depth } = queue.shift();
+                if (depth > maxDepth)
+                    continue;
+                const valueKey = JSON.stringify(value);
+                if (visited.has(valueKey))
+                    continue;
+                visited.add(valueKey);
+                // Find matching documents
+                for (const foreignDoc of foreignCollection) {
+                    const foreignValue = this.getNestedValue(foreignDoc, connectToField);
+                    if (this.valuesMatch(value, foreignValue)) {
+                        // Check restrictSearchWithMatch
+                        if (restrictSearchWithMatch) {
+                            const matchQuery = new plugins.mingo.Query(restrictSearchWithMatch);
+                            if (!matchQuery.test(foreignDoc))
+                                continue;
+                        }
+                        const resultDoc = depthField
+                            ? { ...foreignDoc, [depthField]: depth }
+                            : { ...foreignDoc };
+                        // Avoid duplicates in results
+                        const docKey = foreignDoc._id.toHexString();
+                        if (!results.some(r => r._id?.toHexString?.() === docKey)) {
+                            results.push(resultDoc);
+                            // Add connected values to queue
+                            const nextValue = this.getNestedValue(foreignDoc, connectFromField);
+                            if (nextValue !== undefined) {
+                                const nextValues = Array.isArray(nextValue) ? nextValue : [nextValue];
+                                for (const nv of nextValues) {
+                                    queue.push({ value: nv, depth: depth + 1 });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                ...doc,
+                [as]: results,
+            };
+        });
+    }
+    /**
+     * Execute a $facet stage manually
+     */
+    static executeFacet(documents, facetSpec) {
+        const result = {};
+        for (const [facetName, pipeline] of Object.entries(facetSpec)) {
+            result[facetName] = this.aggregate(documents, pipeline);
+        }
+        return result;
+    }
+    /**
+     * Execute a $unionWith stage
+     */
+    static executeUnionWith(documents, otherDocuments, pipeline) {
+        let unionDocs = otherDocuments;
+        if (pipeline && pipeline.length > 0) {
+            unionDocs = this.aggregate(otherDocuments, pipeline);
+        }
+        return [...documents, ...unionDocs];
+    }
+    /**
+     * Execute a $merge stage (output to another collection)
+     * Returns the documents that would be inserted/updated
+     */
+    static prepareMerge(documents, mergeSpec) {
+        const onField = mergeSpec.on || '_id';
+        const whenMatched = mergeSpec.whenMatched || 'merge';
+        const whenNotMatched = mergeSpec.whenNotMatched || 'insert';
+        return {
+            toInsert: [],
+            toUpdate: [],
+            onField,
+            whenMatched,
+            whenNotMatched,
+        };
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    static getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    static valuesMatch(a, b) {
+        if (a === b)
+            return true;
+        // Handle ObjectId comparison
+        if (a instanceof plugins.bson.ObjectId && b instanceof plugins.bson.ObjectId) {
+            return a.equals(b);
+        }
+        // Handle array contains check
+        if (Array.isArray(a)) {
+            return a.some(item => this.valuesMatch(item, b));
+        }
+        if (Array.isArray(b)) {
+            return b.some(item => this.valuesMatch(a, item));
+        }
+        // Handle Date comparison
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        // Handle object comparison
+        if (typeof a === 'object' && typeof b === 'object' && a !== null && b !== null) {
+            return JSON.stringify(a) === JSON.stringify(b);
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AggregationEngine.js","sourceRoot":"","sources":["../../../ts/ts_smartdb/engine/AggregationEngine.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_smartdb/engine/IndexEngine.d.ts

@@ -0,0 +1,97 @@
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+declare class SimpleBTree<K, V> {
+    private entries;
+    private sortedKeys;
+    private comparator;
+    constructor(_unused?: undefined, comparator?: (a: K, b: K) => number);
+    private keyToString;
+    set(key: K, value: V): boolean;
+    get(key: K): V | undefined;
+    delete(key: K): boolean;
+    forRange(lowKey: K | undefined, highKey: K | undefined, lowInclusive: boolean, highInclusive: boolean, callback: (value: V, key: K) => void): void;
+}
+import type { Document, IStoredDocument, IIndexInfo, ICreateIndexOptions } from '../types/interfaces.js';
+/**
+ * Index data structure using B-Tree for range queries
+ */
+interface IIndexData {
+    name: string;
+    key: Record<string, 1 | -1 | string>;
+    unique: boolean;
+    sparse: boolean;
+    expireAfterSeconds?: number;
+    btree: SimpleBTree<any, Set<string>>;
+    hashMap: Map<string, Set<string>>;
+}
+/**
+ * Index engine for managing indexes and query optimization
+ */
+export declare class IndexEngine {
+    private dbName;
+    private collName;
+    private storage;
+    private indexes;
+    private initialized;
+    constructor(dbName: string, collName: string, storage: IStorageAdapter);
+    /**
+     * Initialize indexes from storage
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create a new index
+     */
+    createIndex(key: Record<string, 1 | -1 | 'text' | '2dsphere'>, options?: ICreateIndexOptions): Promise<string>;
+    /**
+     * Drop an index
+     */
+    dropIndex(name: string): Promise<void>;
+    /**
+     * Drop all indexes except _id
+     */
+    dropAllIndexes(): Promise<void>;
+    /**
+     * List all indexes
+     */
+    listIndexes(): Promise<IIndexInfo[]>;
+    /**
+     * Check if an index exists
+     */
+    indexExists(name: string): Promise<boolean>;
+    /**
+     * Update index entries after document insert
+     */
+    onInsert(doc: IStoredDocument): Promise<void>;
+    /**
+     * Update index entries after document update
+     */
+    onUpdate(oldDoc: IStoredDocument, newDoc: IStoredDocument): Promise<void>;
+    /**
+     * Update index entries after document delete
+     */
+    onDelete(doc: IStoredDocument): Promise<void>;
+    /**
+     * Find the best index for a query
+     */
+    selectIndex(filter: Document): {
+        name: string;
+        data: IIndexData;
+    } | null;
+    /**
+     * Analyze filter to extract field operators
+     */
+    private analyzeFilter;
+    /**
+     * Use index to find candidate document IDs (supports range queries with B-tree)
+     */
+    findCandidateIds(filter: Document): Promise<Set<string> | null>;
+    /**
+     * Find candidates using B-tree range scan
+     */
+    private findRangeCandidates;
+    private generateIndexName;
+    private extractKeyValue;
+    private buildKeyValue;
+    private getFilterFields;
+    private getFilterValue;
+}
+export {};