mongo.do 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,21 +1,2741 @@
+import { S as SQLStorage, I as IndexInfo, c as IndexSpec, C as CreateIndexOptions, d as CreateIndexResult, D as DropIndexResult, T as TTLIndexInfo, e as ExpiredDocumentsQuery, f as TTLMetadata, g as TTLCleanupResult, O as ObjectId$1, P as PipelineStage, R as RpcClientOptions, h as EventHandler, i as RpcRequest, j as DeduplicatorOptions } from './worker-entrypoint-BEW23Gmp.js';
+export { G as BatchResponse, X as BatchedExecutorOptions, a3 as BatchedRpcExecutor, V as CollectionRef, a8 as DEFAULT_OPTIONS, U as DatabaseRef, w as DurableObjectId, v as DurableObjectNamespace, x as DurableObjectStub, o as ErrorCode, $ as ErrorCodeValue, E as ExecutionContext, K as HttpRpcErrorResponse, H as HttpRpcRequest, L as HttpRpcResponse, J as HttpRpcSuccessResponse, N as LegacyRpcRequest, Q as LegacyRpcResponse, u as MessageType, a9 as MondoBindings, b as MondoDatabase, a as MondoEntrypoint, aa as MondoEntrypointOptions, M as MondoEnv, a1 as MondoRpcTarget, Y as PipelineOp, a4 as PipelineTracker, a5 as PipelinedRpcProxy, Z as ReconnectEvent, _ as RpcHandler, M as RpcMondoEnv, F as RpcResponse, a0 as RpcTarget, m as SCHEMA_TABLES, l as SCHEMA_VERSION, n as SQLStatement, k as SchemaManager, z as WorkerCode, W as WorkerEntrypoint, B as WorkerEntrypointType, y as WorkerLoader, A as WorkerStub, a as default, q as errorResponse, p as getErrorCodeName, a7 as isMondoEnv, t as legacyErrorResponse, r as legacySuccessResponse, a2 as newWorkersRpcResponse, s as successResponse, a6 as validateEnv } from './worker-entrypoint-BEW23Gmp.js';
+import { DurableObjectNamespace } from '@cloudflare/workers-types';
+import { EventEmitter } from 'events';
+
 /**
- * mongo.do - MongoDB-compatible database backed by Cloudflare Durable Objects SQLite
- *
- * Main entry point for the package.
- */
-export { ObjectId } from './types/objectid';
-export { MondoDatabase } from './durable-object/mondo-database';
-export { SchemaManager, SCHEMA_VERSION, SCHEMA_TABLES } from './durable-object/schema';
-export { IndexManager, generateIndexName, generateSQLiteIndexName, buildCreateIndexSQL, } from './durable-object/index-manager';
-export type { SQLStorage, SQLStatement } from './durable-object/index-manager';
-export type { IndexSpec, CreateIndexOptions, CreateIndexResult, IndexInfo, DropIndexResult, } from './types';
-export { MongoCollection } from './client/mongo-collection';
-export { ErrorCode, getErrorCodeName, successResponse, errorResponse, legacySuccessResponse, legacyErrorResponse, MessageType, } from './types/rpc';
-export type { DurableObjectNamespace, DurableObjectId, DurableObjectStub, MondoEnv, WorkerLoader, WorkerCode, WorkerStub, WorkerEntrypoint as WorkerEntrypointType, RpcRequest, RpcResponse, BatchResponse, HttpRpcRequest, HttpRpcSuccessResponse, HttpRpcErrorResponse, HttpRpcResponse, LegacyRpcRequest, LegacyRpcResponse, DatabaseRef, CollectionRef, BatchedExecutorOptions, PipelineOp, RpcClientOptions, DeduplicatorOptions, EventHandler, ReconnectEvent, RpcHandler, ErrorCodeValue, } from './types/rpc';
-export { RpcTarget, MondoRpcTarget, newWorkersRpcResponse, BatchedRpcExecutor, PipelineTracker, PipelinedRpcProxy, } from './rpc/rpc-target';
-export type { MondoEnv as RpcMondoEnv } from './types/rpc';
-export { RpcClient, MongoClient, WebSocketRpcTransport, RequestDeduplicator, } from './rpc/rpc-client';
-export { WorkerEntrypoint, MondoEntrypoint, validateEnv, isMondoEnv, DEFAULT_OPTIONS, } from './rpc/worker-entrypoint';
-export type { ExecutionContext, MondoBindings, MondoEntrypointOptions, } from './rpc/worker-entrypoint';
-export { MondoEntrypoint as default } from './rpc/worker-entrypoint';
-//# sourceMappingURL=index.d.ts.map
+ * Index Manager for mongo.do
+ *
+ * Manages SQLite indexes for MongoDB-style collections backed by Durable Objects.
+ * Indexes are created on json_extract expressions to enable efficient querying.
+ *
+ * TTL (Time-To-Live) Index Support:
+ * - createIndex({field: 1}, {expireAfterSeconds: N}) creates a TTL index
+ * - Documents with date values in the TTL field will expire after N seconds
+ * - Background cleanup removes expired documents periodically
+ */
+
+/**
+ * Generates an index name from collection name and key specification
+ */
+declare function generateIndexName(collectionName: string, keys: IndexSpec): string;
+/**
+ * Generates the SQLite index name (prefixed for internal use)
+ */
+declare function generateSQLiteIndexName(collectionName: string, keys: IndexSpec, unique?: boolean): string;
+/**
+ * Builds the SQL CREATE INDEX statement for given index specification
+ */
+declare function buildCreateIndexSQL(collectionName: string, collectionId: number, keys: IndexSpec, options?: CreateIndexOptions): {
+    sql: string;
+    indexName: string;
+    sqliteIndexName: string;
+};
+/**
+ * IndexManager handles creation, deletion, and listing of indexes
+ * Includes TTL (Time-To-Live) index support for automatic document expiration
+ */
+declare class IndexManager {
+    private storage;
+    private cleanupIntervalMs;
+    private ttlMetadataCache;
+    constructor(storage: SQLStorage);
+    /**
+     * Ensure the collections and documents tables exist.
+     *
+     * UNIFIED SCHEMA: This uses the same schema as MondoDatabase/SchemaManager.
+     * The schema is defined in schema.ts/migrations.ts as the single source of truth.
+     * This method creates the tables if they don't exist (for standalone IndexManager usage).
+     */
+    ensureMetadataTable(): void;
+    /**
+     * Get or create a collection and return its ID
+     */
+    getOrCreateCollection(name: string): {
+        id: number;
+        created: boolean;
+    };
+    /**
+     * Get collection metadata
+     */
+    getCollection(name: string): {
+        id: number;
+        indexes: IndexInfo[];
+    } | null;
+    /**
+     * Create an index on a collection
+     */
+    createIndex(collectionName: string, keys: IndexSpec, options?: CreateIndexOptions): CreateIndexResult;
+    /**
+     * List all indexes on a collection
+     */
+    listIndexes(collectionName: string): IndexInfo[];
+    /**
+     * Drop a specific index by name
+     */
+    dropIndex(collectionName: string, indexName: string): DropIndexResult;
+    /**
+     * Drop all indexes on a collection (except _id)
+     */
+    dropIndexes(collectionName: string): DropIndexResult;
+    /**
+     * Get index usage hints for a query
+     * Returns suggested index names that could be used for the query
+     */
+    getIndexHints(collectionName: string, queryFields: string[]): string[];
+    /**
+     * Get all TTL indexes across all collections
+     */
+    getTTLIndexes(): TTLIndexInfo[];
+    /**
+     * Check if a specific index is a TTL index
+     */
+    isTTLIndex(collectionName: string, indexName: string): boolean;
+    /**
+     * Check if a value is a valid date for TTL purposes
+     * Accepts Date objects, ISO strings, and Unix timestamps (in ms)
+     */
+    isValidTTLFieldValue(value: unknown): boolean;
+    /**
+     * Calculate expiration time for a document
+     */
+    calculateExpirationTime(dateValue: Date | string | number, expireAfterSeconds: number): Date;
+    /**
+     * Check if a document is expired based on its TTL field
+     */
+    isDocumentExpired(document: Record<string, unknown>, field: string, expireAfterSeconds: number): boolean;
+    /**
+     * Build SQL query to delete expired documents for a collection
+     */
+    buildExpiredDocumentsQuery(collectionName: string, field: string, expireAfterSeconds: number): ExpiredDocumentsQuery;
+    /**
+     * Get TTL metadata for a specific index
+     */
+    getTTLMetadata(collectionName: string, indexName: string): TTLMetadata | null;
+    /**
+     * Record a TTL cleanup operation for tracking purposes
+     */
+    recordTTLCleanup(collectionName: string, indexName: string, deletedCount: number): void;
+    /**
+     * Get the next cleanup time based on the configured interval
+     */
+    getNextCleanupTime(): number;
+    /**
+     * Set the cleanup interval in milliseconds
+     */
+    setCleanupInterval(intervalMs: number): void;
+    /**
+     * Run TTL cleanup across all collections with TTL indexes
+     * Deletes all expired documents and returns cleanup statistics
+     */
+    runTTLCleanup(): Promise<TTLCleanupResult>;
+}
+
+/**
+ * Cloudflare Vectorize types for vector search
+ *
+ * These interfaces match the Cloudflare Vectorize API for compatibility
+ * with the Workers AI embeddings and vector similarity search.
+ */
+/**
+ * Supported metadata value types for vector storage
+ */
+type VectorizeMetadataValue = string | number | boolean | string[];
+/**
+ * Metadata object attached to vectors
+ */
+type VectorizeMetadata = Record<string, VectorizeMetadataValue>;
+/**
+ * A vector with its ID, values, and optional metadata
+ */
+interface VectorizeVector {
+    /** Unique identifier for the vector */
+    id: string;
+    /** The embedding vector values */
+    values: number[] | Float32Array | Float64Array;
+    /** Optional namespace for organizing vectors */
+    namespace?: string;
+    /** Optional metadata attached to the vector */
+    metadata?: VectorizeMetadata;
+}
+/**
+ * Options for querying vectors
+ */
+interface VectorizeQueryOptions {
+    /** Number of results to return (default: 10) */
+    topK?: number;
+    /** Optional namespace to search within */
+    namespace?: string;
+    /** Whether to return vector values (default: false) */
+    returnValues?: boolean;
+    /** Whether to return metadata (default: false) */
+    returnMetadata?: 'none' | 'indexed' | 'all';
+    /** Optional filter expression for metadata filtering */
+    filter?: Record<string, VectorizeMetadataValue>;
+}
+/**
+ * A match result from a vector query
+ */
+interface VectorizeMatch {
+    /** The vector ID */
+    id: string;
+    /** Similarity score (higher is more similar) */
+    score: number;
+    /** The vector values (if returnValues was true) */
+    values?: number[];
+    /** The metadata (if returnMetadata was set) */
+    metadata?: VectorizeMetadata;
+}
+/**
+ * Result from a vector query operation
+ */
+interface VectorizeQueryResult {
+    /** Number of matches returned */
+    count: number;
+    /** The matching vectors */
+    matches: VectorizeMatch[];
+}
+/**
+ * Result from a vector mutation operation (insert, upsert, delete)
+ */
+interface VectorizeMutationResult {
+    /** Number of vectors affected */
+    count: number;
+    /** IDs of affected vectors */
+    ids: string[];
+}
+/**
+ * Vectorize index interface matching Cloudflare's API
+ */
+interface VectorizeIndex {
+    /**
+     * Query the index for similar vectors
+     * @param vector - The query vector
+     * @param options - Query options
+     */
+    query(vector: number[] | Float32Array | Float64Array, options?: VectorizeQueryOptions): Promise<VectorizeQueryResult>;
+    /**
+     * Insert vectors into the index
+     * @param vectors - Vectors to insert
+     */
+    insert(vectors: VectorizeVector[]): Promise<VectorizeMutationResult>;
+    /**
+     * Upsert vectors into the index (insert or update)
+     * @param vectors - Vectors to upsert
+     */
+    upsert(vectors: VectorizeVector[]): Promise<VectorizeMutationResult>;
+    /**
+     * Delete vectors by ID
+     * @param ids - IDs of vectors to delete
+     */
+    deleteByIds(ids: string[]): Promise<VectorizeMutationResult>;
+    /**
+     * Get vectors by ID
+     * @param ids - IDs of vectors to retrieve
+     */
+    getByIds(ids: string[]): Promise<VectorizeVector[]>;
+    /**
+     * Describe the index configuration
+     */
+    describe(): Promise<{
+        dimensions: number;
+        vectorsCount: number;
+        config: {
+            dimensions: number;
+            metric: 'cosine' | 'euclidean' | 'dot-product';
+        };
+    }>;
+}
+/**
+ * Workers AI binding interface for embeddings
+ */
+interface Ai {
+    /**
+     * Run an AI model
+     * @param model - The model identifier (e.g., '@cf/baai/bge-m3')
+     * @param inputs - The inputs for the model
+     */
+    run<T = unknown>(model: string, inputs: Record<string, unknown>): Promise<T>;
+}
+
+/**
+ * Cloudflare Workers environment bindings
+ */
+
+/**
+ * Environment interface for Cloudflare Workers
+ */
+interface Env {
+    /**
+     * Durable Object namespace for MondoDatabase instances
+     */
+    MONDO_DATABASE: DurableObjectNamespace;
+    /**
+     * Optional Vectorize index binding for vector search
+     */
+    VECTORIZE?: VectorizeIndex;
+    /**
+     * Optional Workers AI binding for generating embeddings
+     */
+    AI?: Ai;
+    /**
+     * Optional embedding model to use (e.g., '@cf/baai/bge-m3')
+     */
+    EMBEDDING_MODEL?: string;
+    /**
+     * Optional flag to enable/disable automatic embedding generation
+     */
+    EMBEDDING_ENABLED?: string;
+}
+
+/**
+ * MongoDB-compatible type definitions
+ */
+/**
+ * A BSON document - the fundamental data structure in MongoDB
+ */
+interface Document$3 {
+    [key: string]: unknown;
+    _id?: string | ObjectId;
+}
+/**
+ * ObjectId type for document identifiers
+ */
+interface ObjectId {
+    toString(): string;
+    toHexString(): string;
+    getTimestamp(): Date;
+}
+/**
+ * Filter query type for finding documents
+ */
+type Filter<T = Document$3> = {
+    [P in keyof T]?: T[P] | FilterOperators<T[P]>;
+} & RootFilterOperators<T>;
+/**
+ * Filter operators like $eq, $gt, $lt, etc.
+ */
+interface FilterOperators<T> {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+    $type?: string | number;
+    $regex?: string | RegExp;
+    $options?: string;
+    $not?: FilterOperators<T>;
+    $elemMatch?: T extends (infer U)[] ? Filter<U & Document$3> : never;
+    $size?: number;
+}
+/**
+ * Root-level filter operators like $and, $or, $nor
+ */
+interface RootFilterOperators<T> {
+    $and?: Filter<T & Document$3>[];
+    $or?: Filter<T & Document$3>[];
+    $nor?: Filter<T & Document$3>[];
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $where?: string | ((this: T) => boolean);
+}
+/**
+ * Update filter type for modifying documents
+ */
+interface UpdateFilter<T extends Document$3 = Document$3> {
+    $set?: Partial<T>;
+    $unset?: {
+        [P in keyof T]?: '' | 1 | true;
+    };
+    $inc?: {
+        [P in keyof T]?: number;
+    };
+    $mul?: {
+        [P in keyof T]?: number;
+    };
+    $min?: Partial<T>;
+    $max?: Partial<T>;
+    $rename?: {
+        [key: string]: string;
+    };
+    $push?: {
+        [P in keyof T]?: T[P] extends (infer U)[] ? U | ArrayUpdateOperators<U> : never;
+    };
+    $pull?: {
+        [P in keyof T]?: T[P] extends (infer U)[] ? U | Filter<U & Document$3> : never;
+    };
+    $addToSet?: {
+        [P in keyof T]?: T[P] extends (infer U)[] ? U | {
+            $each: U[];
+        } : never;
+    };
+    $pop?: {
+        [P in keyof T]?: 1 | -1;
+    };
+    $currentDate?: {
+        [P in keyof T]?: true | {
+            $type: 'date' | 'timestamp';
+        };
+    };
+}
+/**
+ * Array update operators for $push
+ */
+interface ArrayUpdateOperators<T> {
+    $each?: T[];
+    $slice?: number;
+    $sort?: 1 | -1 | {
+        [key: string]: 1 | -1;
+    };
+    $position?: number;
+}
+/**
+ * Options for find operations
+ */
+interface FindOptions$2<T extends Document$3 = Document$3> {
+    projection?: {
+        [P in keyof T]?: 0 | 1 | boolean;
+    } | undefined;
+    sort?: {
+        [P in keyof T]?: 1 | -1;
+    } | [string, 1 | -1][] | undefined;
+    skip?: number | undefined;
+    limit?: number | undefined;
+    hint?: string | {
+        [key: string]: 1 | -1;
+    } | undefined;
+    maxTimeMS?: number | undefined;
+    readConcern?: {
+        level: 'local' | 'majority' | 'linearizable' | 'available' | 'snapshot';
+    } | undefined;
+}
+/**
+ * Result of insertOne operation
+ */
+interface InsertOneResult$1 {
+    acknowledged: boolean;
+    insertedId: string | ObjectId;
+}
+/**
+ * Result of insertMany operation
+ */
+interface InsertManyResult$1 {
+    acknowledged: boolean;
+    insertedCount: number;
+    insertedIds: {
+        [key: number]: string | ObjectId;
+    };
+}
+/**
+ * Result of update operations
+ */
+interface UpdateResult$1 {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedCount: number;
+    upsertedId?: string | ObjectId;
+}
+/**
+ * Result of delete operations
+ */
+interface DeleteResult$1 {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+/**
+ * Options for aggregation pipeline
+ */
+interface AggregateOptions {
+    allowDiskUse?: boolean | undefined;
+    maxTimeMS?: number | undefined;
+    bypassDocumentValidation?: boolean | undefined;
+    readConcern?: {
+        level: string;
+    } | undefined;
+    collation?: CollationOptions | undefined;
+    hint?: string | Document$3 | undefined;
+    comment?: string | undefined;
+    let?: Document$3 | undefined;
+}
+/**
+ * Collation options for string comparison
+ */
+interface CollationOptions {
+    locale: string;
+    caseLevel?: boolean;
+    caseFirst?: 'upper' | 'lower' | 'off';
+    strength?: 1 | 2 | 3 | 4 | 5;
+    numericOrdering?: boolean;
+    alternate?: 'non-ignorable' | 'shifted';
+    maxVariable?: 'punct' | 'space';
+    backwards?: boolean;
+}
+/**
+ * Index specification for createIndex
+ */
+interface IndexSpecification {
+    key: {
+        [key: string]: 1 | -1 | 'text' | '2dsphere' | '2d' | 'hashed';
+    };
+    name?: string;
+    unique?: boolean;
+    sparse?: boolean;
+    background?: boolean;
+    expireAfterSeconds?: number;
+    partialFilterExpression?: Filter;
+    collation?: CollationOptions;
+}
+/**
+ * Aggregation pipeline stage types
+ */
+type AggregationStage = {
+    $match: Filter;
+} | {
+    $project: Document$3;
+} | {
+    $group: {
+        _id: unknown;
+        [key: string]: unknown;
+    };
+} | {
+    $sort: {
+        [key: string]: 1 | -1;
+    };
+} | {
+    $limit: number;
+} | {
+    $skip: number;
+} | {
+    $unwind: string | {
+        path: string;
+        preserveNullAndEmptyArrays?: boolean;
+    };
+} | {
+    $lookup: LookupStage;
+} | {
+    $addFields: Document$3;
+} | {
+    $replaceRoot: {
+        newRoot: string | Document$3;
+    };
+} | {
+    $count: string;
+} | {
+    $facet: {
+        [key: string]: AggregationStage[];
+    };
+};
+/**
+ * $lookup stage configuration
+ */
+interface LookupStage {
+    from: string;
+    localField?: string;
+    foreignField?: string;
+    as: string;
+    let?: Document$3;
+    pipeline?: AggregationStage[];
+}
+
+/**
+ * HTTP Cursors - MongoDB-compatible cursor implementations for HTTP client
+ *
+ * These cursors wrap HTTP requests to provide lazy evaluation, streaming,
+ * and MongoDB-compatible iteration patterns for find() and aggregate() operations.
+ */
+
+/**
+ * Sort direction: 1 for ascending, -1 for descending
+ */
+type SortDirection = 1 | -1;
+/**
+ * Sort specification with field names and directions
+ */
+type SortSpec = Record<string, SortDirection>;
+/**
+ * Projection specification: 1 to include, 0 to exclude
+ */
+type ProjectionSpec = Record<string, 0 | 1>;
+/**
+ * HTTP request function type
+ */
+type HttpRequestFn<T> = (method: string, path: string, body?: unknown) => Promise<T>;
+/**
+ * HttpFindCursor - Cursor for find() operations via HTTP
+ *
+ * Provides MongoDB-compatible cursor interface with:
+ * - Lazy evaluation (data fetched on first access)
+ * - Chainable modifiers (sort, limit, skip, project)
+ * - Async iteration support
+ * - toArray() for collecting all results
+ */
+declare class HttpFindCursor<TDocument extends Document$3 = Document$3> {
+    private readonly requestFn;
+    private readonly filter;
+    private _sort?;
+    private _limit?;
+    private _skip?;
+    private _projection?;
+    private _batchSize?;
+    private _buffer;
+    private _position;
+    private _fetched;
+    private _closed;
+    private _error;
+    /**
+     * Create a new HttpFindCursor
+     *
+     * @param requestFn - Function to make HTTP requests
+     * @param filter - Query filter
+     * @param options - Initial find options
+     */
+    constructor(requestFn: HttpRequestFn<TDocument[]>, filter?: Filter<TDocument>, options?: FindOptions$2<TDocument>);
+    /**
+     * Whether the cursor is closed
+     */
+    get closed(): boolean;
+    /**
+     * Number of documents currently buffered
+     */
+    get bufferedCount(): number;
+    /**
+     * Set the sort order for documents
+     */
+    sort(spec: SortSpec): this;
+    /**
+     * Set a limit on the number of documents to return
+     */
+    limit(count: number): this;
+    /**
+     * Set the number of documents to skip
+     */
+    skip(count: number): this;
+    /**
+     * Set the projection for returned documents
+     */
+    project(spec: ProjectionSpec): this;
+    /**
+     * Set the batch size for streaming (hint for server)
+     */
+    batchSize(size: number): this;
+    /**
+     * Ensure data has been fetched from the server
+     */
+    private ensureFetched;
+    /**
+     * Get the next document from the cursor
+     * Returns null when exhausted
+     */
+    next(): Promise<TDocument | null>;
+    /**
+     * Check if there are more documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get all documents as an array
+     */
+    toArray(): Promise<TDocument[]>;
+    /**
+     * Iterate over all documents with a callback
+     * Return false from callback to stop iteration
+     */
+    forEach(callback: (doc: TDocument, index: number) => void | false | Promise<void | false>): Promise<void>;
+    /**
+     * Transform documents with a mapping function
+     */
+    map<U>(fn: (doc: TDocument, index: number) => U): MappedHttpCursor<TDocument, U>;
+    /**
+     * Count documents without consuming the cursor
+     */
+    count(): Promise<number>;
+    /**
+     * Close the cursor and release resources
+     */
+    close(): Promise<void>;
+    /**
+     * Clone this cursor with the same options
+     */
+    clone(): HttpFindCursor<TDocument>;
+    /**
+     * Async iterator implementation
+     * Supports for-await-of syntax
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TDocument>;
+}
+/**
+ * Mapped cursor for transformed results
+ */
+declare class MappedHttpCursor<TDocument extends Document$3, U> {
+    private readonly _cursor;
+    private readonly _mapFn;
+    constructor(cursor: HttpFindCursor<TDocument>, mapFn: (doc: TDocument, index: number) => U);
+    toArray(): Promise<U[]>;
+    forEach(callback: (doc: U, index: number) => void | false | Promise<void | false>): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<U>;
+}
+/**
+ * HttpAggregationCursor - Cursor for aggregate() operations via HTTP
+ *
+ * Provides MongoDB-compatible cursor interface with:
+ * - Lazy evaluation (pipeline executed on first access)
+ * - Async iteration support
+ * - toArray() for collecting all results
+ */
+declare class HttpAggregationCursor<TResult extends Document$3 = Document$3> {
+    private readonly requestFn;
+    private readonly pipeline;
+    private readonly options;
+    private _buffer;
+    private _position;
+    private _fetched;
+    private _closed;
+    private _error;
+    /**
+     * Create a new HttpAggregationCursor
+     *
+     * @param requestFn - Function to make HTTP requests
+     * @param pipeline - Aggregation pipeline stages
+     * @param options - Aggregation options
+     */
+    constructor(requestFn: HttpRequestFn<TResult[]>, pipeline: AggregationStage[], options?: AggregateOptions);
+    /**
+     * Whether the cursor is closed
+     */
+    get closed(): boolean;
+    /**
+     * Number of documents currently buffered
+     */
+    get bufferedCount(): number;
+    /**
+     * Ensure data has been fetched from the server
+     */
+    private ensureFetched;
+    /**
+     * Get the next document from the cursor
+     * Returns null when exhausted
+     */
+    next(): Promise<TResult | null>;
+    /**
+     * Check if there are more documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get all documents as an array
+     */
+    toArray(): Promise<TResult[]>;
+    /**
+     * Iterate over all documents with a callback
+     * Return false from callback to stop iteration
+     */
+    forEach(callback: (doc: TResult, index: number) => void | false | Promise<void | false>): Promise<void>;
+    /**
+     * Transform documents with a mapping function
+     */
+    map<U>(fn: (doc: TResult, index: number) => U): MappedHttpAggregationCursor<TResult, U>;
+    /**
+     * Close the cursor and release resources
+     */
+    close(): Promise<void>;
+    /**
+     * Clone this cursor with the same options
+     */
+    clone(): HttpAggregationCursor<TResult>;
+    /**
+     * Async iterator implementation
+     * Supports for-await-of syntax
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TResult>;
+    /**
+     * Explain the aggregation plan (returns pipeline stages)
+     */
+    explain(): {
+        pipeline: AggregationStage[];
+        options: AggregateOptions;
+    };
+}
+/**
+ * Mapped aggregation cursor for transformed results
+ */
+declare class MappedHttpAggregationCursor<TResult extends Document$3, U> {
+    private readonly _cursor;
+    private readonly _mapFn;
+    constructor(cursor: HttpAggregationCursor<TResult>, mapFn: (doc: TResult, index: number) => U);
+    toArray(): Promise<U[]>;
+    forEach(callback: (doc: U, index: number) => void | false | Promise<void | false>): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<U>;
+}
+
+/**
+ * Collection - MongoDB-compatible collection interface
+ *
+ * Provides CRUD operations on documents within a collection.
+ */
+
+/**
+ * Collection class
+ *
+ * Provides MongoDB-compatible operations on a collection of documents.
+ */
+declare class Collection$1<TDocument extends Document$3 = Document$3> {
+    private env;
+    private dbName;
+    private collectionName;
+    /**
+     * Create a new Collection instance
+     *
+     * @param env - Cloudflare Workers environment with MONDO_DATABASE binding
+     * @param dbName - The name of the database
+     * @param collectionName - The name of the collection
+     */
+    constructor(env: Env, dbName: string, collectionName: string);
+    /**
+     * Get the Durable Object stub for this collection's database
+     */
+    private getStub;
+    /**
+     * Make a request to the Durable Object
+     */
+    private request;
+    /**
+     * Insert a single document
+     *
+     * @param doc - The document to insert
+     * @returns InsertOneResult with the inserted document's _id
+     */
+    insertOne(doc: Omit<TDocument, '_id'> | TDocument): Promise<InsertOneResult$1>;
+    /**
+     * Insert multiple documents
+     *
+     * @param docs - Array of documents to insert
+     * @returns InsertManyResult with count and inserted IDs
+     */
+    insertMany(docs: Array<Omit<TDocument, '_id'> | TDocument>): Promise<InsertManyResult$1>;
+    /**
+     * Find a single document matching the filter
+     *
+     * @param filter - Query filter
+     * @param options - Find options (projection, sort, etc.)
+     * @returns The matching document or null
+     */
+    findOne(filter?: Filter<TDocument>, options?: FindOptions$2<TDocument>): Promise<TDocument | null>;
+    /**
+     * Find all documents matching the filter
+     *
+     * Returns a cursor that supports:
+     * - Async iteration with `for await (const doc of cursor)`
+     * - Converting to array with `await cursor.toArray()`
+     * - Chainable modifiers: sort(), limit(), skip(), project()
+     *
+     * @param filter - Query filter
+     * @param options - Find options (projection, sort, skip, limit, etc.)
+     * @returns HttpFindCursor for iterating over results
+     *
+     * @example
+     * ```typescript
+     * // Using toArray
+     * const docs = await collection.find({ status: 'active' }).toArray()
+     *
+     * // Using async iterator
+     * for await (const doc of collection.find({ status: 'active' })) {
+     *   console.log(doc)
+     * }
+     *
+     * // Using chainable modifiers
+     * const docs = await collection.find({})
+     *   .sort({ name: 1 })
+     *   .limit(10)
+     *   .skip(5)
+     *   .toArray()
+     * ```
+     */
+    find(filter?: Filter<TDocument>, options?: FindOptions$2<TDocument>): HttpFindCursor<TDocument>;
+    /**
+     * Update a single document matching the filter
+     *
+     * @param filter - Query filter
+     * @param update - Update operations
+     * @returns UpdateResult with match and modify counts
+     */
+    updateOne(filter: Filter<TDocument>, update: UpdateFilter<TDocument>): Promise<UpdateResult$1>;
+    /**
+     * Update all documents matching the filter
+     *
+     * @param filter - Query filter
+     * @param update - Update operations
+     * @returns UpdateResult with match and modify counts
+     */
+    updateMany(filter: Filter<TDocument>, update: UpdateFilter<TDocument>): Promise<UpdateResult$1>;
+    /**
+     * Replace a single document matching the filter
+     *
+     * @param filter - Query filter
+     * @param replacement - The replacement document
+     * @returns UpdateResult
+     */
+    replaceOne(filter: Filter<TDocument>, replacement: Omit<TDocument, '_id'>): Promise<UpdateResult$1>;
+    /**
+     * Delete a single document matching the filter
+     *
+     * @param filter - Query filter
+     * @returns DeleteResult with deleted count
+     */
+    deleteOne(filter: Filter<TDocument>): Promise<DeleteResult$1>;
+    /**
+     * Delete all documents matching the filter
+     *
+     * @param filter - Query filter
+     * @returns DeleteResult with deleted count
+     */
+    deleteMany(filter: Filter<TDocument>): Promise<DeleteResult$1>;
+    /**
+     * Count documents matching the filter
+     *
+     * @param filter - Query filter
+     * @returns Number of matching documents
+     */
+    countDocuments(filter?: Filter<TDocument>): Promise<number>;
+    /**
+     * Get estimated document count (faster but less accurate)
+     *
+     * @returns Estimated number of documents
+     */
+    estimatedDocumentCount(): Promise<number>;
+    /**
+     * Execute an aggregation pipeline
+     *
+     * Returns a cursor that supports:
+     * - Async iteration with `for await (const doc of cursor)`
+     * - Converting to array with `await cursor.toArray()`
+     * - forEach iteration with `await cursor.forEach(callback)`
+     *
+     * @param pipeline - Array of aggregation stages
+     * @param options - Aggregation options
+     * @returns HttpAggregationCursor for iterating over results
+     *
+     * @example
+     * ```typescript
+     * // Using toArray
+     * const results = await collection.aggregate([
+     *   { $match: { status: 'active' } },
+     *   { $group: { _id: '$category', count: { $sum: 1 } } }
+     * ]).toArray()
+     *
+     * // Using async iterator
+     * for await (const doc of collection.aggregate([
+     *   { $match: { status: 'active' } }
+     * ])) {
+     *   console.log(doc)
+     * }
+     * ```
+     */
+    aggregate<TResult extends Document$3 = Document$3>(pipeline: AggregationStage[], options?: AggregateOptions): HttpAggregationCursor<TResult>;
+    /**
+     * Get distinct values for a field
+     *
+     * @param field - The field to get distinct values for
+     * @param filter - Optional filter
+     * @returns Array of distinct values
+     */
+    distinct<TValue = unknown>(field: keyof TDocument, filter?: Filter<TDocument>): Promise<TValue[]>;
+    /**
+     * Create an index on this collection
+     *
+     * @param indexSpec - Index specification
+     * @returns Name of the created index
+     */
+    createIndex(indexSpec: IndexSpecification): Promise<string>;
+    /**
+     * Drop an index from this collection
+     *
+     * @param indexName - Name of the index to drop
+     */
+    dropIndex(indexName: string): Promise<void>;
+    /**
+     * List all indexes on this collection
+     *
+     * @returns Array of index information
+     */
+    listIndexes(): Promise<IndexSpecification[]>;
+    /**
+     * Drop this collection
+     */
+    drop(): Promise<void>;
+}
+
+/**
+ * Database - MongoDB-compatible database interface
+ *
+ * Represents a database in mongo.do and provides access to collections.
+ */
+
+/**
+ * Database class
+ *
+ * Provides access to collections within a database.
+ * Each database corresponds to a Durable Object instance.
+ */
+declare class Database$1 {
+    private env;
+    private dbName;
+    /**
+     * Create a new Database instance
+     *
+     * @param env - Cloudflare Workers environment with MONDO_DATABASE binding
+     * @param name - The name of the database
+     */
+    constructor(env: Env, name: string);
+    /**
+     * Get the name of this database
+     */
+    get databaseName(): string;
+    /**
+     * Get a collection from this database
+     *
+     * @param name - The name of the collection
+     * @returns A Collection instance
+     */
+    collection<TDocument extends Record<string, unknown> = Record<string, unknown>>(name: string): Collection$1<TDocument>;
+    /**
+     * List all collections in this database
+     *
+     * @returns Array of collection names
+     */
+    listCollections(): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * Create a new collection
+     *
+     * @param name - The name of the collection to create
+     * @returns void
+     */
+    createCollection(name: string): Promise<void>;
+    /**
+     * Drop a collection from this database
+     *
+     * @param name - The name of the collection to drop
+     * @returns true if collection was dropped, false if it didn't exist
+     */
+    dropCollection(name: string): Promise<boolean>;
+    /**
+     * Get database statistics
+     */
+    stats(): Promise<{
+        db: string;
+        collections: number;
+        objects: number;
+        dataSize: number;
+    }>;
+}
+
+/**
+ * ClientSession - MongoDB-compatible session for transaction support
+ *
+ * Provides transaction management APIs compatible with MongoDB driver:
+ * - startTransaction(options)
+ * - commitTransaction()
+ * - abortTransaction()
+ * - withTransaction(callback, options)
+ *
+ * Maps MongoDB transactions to SQLite BEGIN/COMMIT/ROLLBACK semantics.
+ */
+/**
+ * Read concern levels supported by MongoDB
+ */
+interface ReadConcern {
+    level: 'local' | 'available' | 'majority' | 'linearizable' | 'snapshot';
+}
+/**
+ * Write concern options supported by MongoDB
+ */
+interface WriteConcern {
+    w?: number | 'majority';
+    wtimeoutMS?: number;
+    journal?: boolean;
+}
+/**
+ * Transaction options for startTransaction and withTransaction
+ */
+interface TransactionOptions {
+    readConcern?: ReadConcern;
+    writeConcern?: WriteConcern;
+    maxCommitTimeMS?: number;
+}
+/**
+ * Session options for startSession
+ */
+interface ClientSessionOptions {
+    defaultTransactionOptions?: TransactionOptions;
+    causalConsistency?: boolean;
+    snapshot?: boolean;
+}
+/**
+ * Transaction states
+ */
+type TransactionState = 'none' | 'starting' | 'in_progress' | 'committed' | 'aborted';
+/**
+ * Session ID structure (MongoDB compatible)
+ */
+declare class SessionId {
+    readonly id: Buffer | Uint8Array;
+    private readonly _hexString;
+    constructor(id: Buffer | Uint8Array);
+    toString(): string;
+    toHexString(): string;
+}
+/**
+ * Transaction callback function type
+ */
+type TransactionCallback<T> = (session: ClientSession) => Promise<T>;
+/**
+ * Forward reference to MongoClient (to avoid circular imports)
+ */
+interface MongoClientLike {
+}
+/**
+ * Interface for collections that support transaction rollback
+ */
+interface TransactableCollection {
+    _getCollectionKey(): string;
+    _createSnapshot(): Map<string, Record<string, unknown>>;
+    _restoreFromSnapshot(snapshot: Map<string, Record<string, unknown>>): void;
+}
+/**
+ * ClientSession provides MongoDB-compatible session and transaction support
+ *
+ * Transactions are mapped to SQLite as follows:
+ * - startTransaction() -> BEGIN TRANSACTION
+ * - commitTransaction() -> COMMIT
+ * - abortTransaction() -> ROLLBACK
+ */
+declare class ClientSession {
+    private readonly _client;
+    private readonly _id;
+    private readonly _options;
+    private _transactionState;
+    private _transactionOptions;
+    private _transactionNumber;
+    private _hasEnded;
+    private _collectionSnapshots;
+    private _trackedCollections;
+    constructor(client: MongoClientLike, options?: ClientSessionOptions);
+    /**
+     * Generate a unique session ID
+     */
+    private _generateSessionId;
+    /**
+     * Get the session ID
+     */
+    get id(): SessionId;
+    /**
+     * Get the client that created this session
+     */
+    get client(): MongoClientLike;
+    /**
+     * Check if the session is currently in a transaction
+     */
+    get inTransaction(): boolean;
+    /**
+     * Get the current transaction state
+     */
+    get transactionState(): TransactionState;
+    /**
+     * Get the current transaction options
+     */
+    get transactionOptions(): TransactionOptions | null;
+    /**
+     * Get the current transaction number
+     */
+    get transactionNumber(): number;
+    /**
+     * Check if the session has ended
+     */
+    get hasEnded(): boolean;
+    /**
+     * Start a new transaction
+     *
+     * Maps to SQLite: BEGIN TRANSACTION
+     *
+     * @param options - Transaction options (readConcern, writeConcern, maxCommitTimeMS)
+     * @throws Error if a transaction is already in progress
+     */
+    startTransaction(options?: TransactionOptions): void;
+    /**
+     * Commit the current transaction
+     *
+     * Maps to SQLite: COMMIT
+     *
+     * @throws Error if no transaction is in progress
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Abort the current transaction
+     *
+     * Maps to SQLite: ROLLBACK
+     *
+     * @throws Error if no transaction is in progress
+     */
+    abortTransaction(): Promise<void>;
+    /**
+     * Execute a callback within a transaction with automatic commit/abort
+     *
+     * This method:
+     * 1. Starts a transaction
+     * 2. Executes the callback
+     * 3. Commits on success, aborts on error
+     * 4. Retries on transient transaction errors
+     *
+     * @param callback - Function to execute within the transaction
+     * @param options - Transaction options
+     * @returns The result of the callback
+     */
+    withTransaction<T>(callback: TransactionCallback<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * End the session
+     *
+     * If a transaction is in progress, it will be aborted.
+     */
+    endSession(): Promise<void>;
+    /**
+     * Mark the transaction as in progress (called on first operation)
+     * @internal
+     */
+    _markInProgress(): void;
+    /**
+     * Track a collection for transaction rollback support
+     * Creates a snapshot of the collection's data on first write operation
+     * @internal
+     */
+    _trackCollection(collection: TransactableCollection): void;
+    /**
+     * Get the SQL command for starting a transaction
+     * @internal
+     */
+    _getBeginCommand(): string;
+    /**
+     * Get the SQL command for committing a transaction
+     * @internal
+     */
+    _getCommitCommand(): string;
+    /**
+     * Get the SQL command for rolling back a transaction
+     * @internal
+     */
+    _getRollbackCommand(): string;
+}
+
+/**
+ * MongoClient - MongoDB-compatible client for mongo.do
+ *
+ * Provides connection management and database access for
+ * MongoDB-compatible operations. Supports two modes:
+ *
+ * 1. URI-based connection (for testing/in-memory):
+ *    const client = new MongoClient('mongodo://localhost:27017/mydb')
+ *
+ * 2. Env-based connection (for Cloudflare Durable Objects):
+ *    const client = new MongoClient(env)
+ *
+ * The URI-based mode uses in-memory storage and is suitable for testing.
+ * The Env-based mode connects to Cloudflare Durable Objects for production.
+ */
+
+/**
+ * Options for MongoClient
+ */
+interface MongoClientOptions {
+    /**
+     * Application name for connection metadata
+     */
+    appName?: string;
+    /**
+     * Host for the connection (URI mode)
+     */
+    host?: string;
+    /**
+     * Port for the connection (URI mode)
+     */
+    port?: number;
+    /**
+     * Maximum connection pool size (URI mode)
+     */
+    maxPoolSize?: number;
+    /**
+     * Minimum connection pool size (URI mode)
+     */
+    minPoolSize?: number;
+    /**
+     * Connection timeout in milliseconds
+     */
+    connectTimeoutMS?: number;
+    /**
+     * Socket timeout in milliseconds
+     */
+    socketTimeoutMS?: number;
+}
+/**
+ * Connection mode for the client
+ */
+type ConnectionMode = 'uri' | 'env';
+/**
+ * MongoClient - The main entry point for interacting with mongo.do
+ *
+ * Provides a MongoDB-compatible API for database operations.
+ * Supports both URI-based connections (for testing) and
+ * Cloudflare Workers environment bindings (for production).
+ *
+ * @example URI-based (testing/in-memory):
+ * ```typescript
+ * const client = new MongoClient('mongodo://localhost:27017/mydb')
+ * await client.connect()
+ * const db = client.db('mydb')
+ * ```
+ *
+ * @example Env-based (Cloudflare Durable Objects):
+ * ```typescript
+ * const client = new MongoClient(env)
+ * await client.connect()
+ * const db = client.db('mydb')
+ * ```
+ */
+declare class MongoClient$1 {
+    private readonly _mode;
+    private readonly _uri?;
+    private readonly _parsedURI?;
+    private readonly _env?;
+    private readonly _options;
+    private _isConnected;
+    private readonly _mongoDatabaseCache;
+    private readonly _databaseCache;
+    /**
+     * Create a new MongoClient instance
+     *
+     * @param uriOrEnv - Either a connection URI string or Cloudflare Workers environment
+     * @param options - Optional connection options
+     */
+    constructor(uriOrEnv: string | Env, options?: MongoClientOptions);
+    /**
+     * Get the client options
+     */
+    get options(): Readonly<MongoClientOptions>;
+    /**
+     * Check if the client is currently connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Get the connection mode
+     */
+    get mode(): ConnectionMode;
+    /**
+     * Get the connection URI (URI mode only)
+     */
+    get uri(): string | undefined;
+    /**
+     * Connect to the database
+     *
+     * In mongo.do, this is mostly a no-op since connections are handled lazily.
+     * For Durable Objects mode, connections are per-request.
+     * For URI mode (in-memory), this initializes the connection state.
+     *
+     * @returns This client for chaining
+     */
+    connect(): Promise<MongoClient$1>;
+    /**
+     * Close the connection
+     *
+     * Clears database caches and resets connection state.
+     */
+    close(): Promise<void>;
+    /**
+     * Get a database instance
+     *
+     * In URI mode, returns a MongoDatabase (in-memory).
+     * In Env mode, returns a Database (Durable Objects).
+     *
+     * @param dbName - Database name (optional in URI mode, uses default from URI)
+     * @returns A database instance (MongoDatabase or Database based on mode)
+     */
+    db(dbName?: string): MongoDatabase | Database$1;
+    /**
+     * Get a MongoDatabase instance (URI/in-memory mode)
+     * @internal
+     */
+    private _getMongoDatabase;
+    /**
+     * Get a Database instance (Env/Durable Objects mode)
+     * @internal
+     */
+    private _getDatabase;
+    /**
+     * Get the default database name from the connection URI
+     * Only available in URI mode.
+     */
+    get defaultDatabase(): string;
+    /**
+     * Start a client session for transaction support
+     *
+     * Sessions are primarily used in URI/in-memory mode.
+     * Durable Objects mode uses SQLite transactions internally.
+     *
+     * @param options - Session options including default transaction options
+     * @returns A new ClientSession instance
+     */
+    startSession(options?: ClientSessionOptions): ClientSession;
+}
+
+/**
+ * MongoDatabase - MongoDB-compatible database interface
+ *
+ * Provides collection access and database-level operations.
+ */
+
+interface CreateCollectionOptions {
+    capped?: boolean;
+    size?: number;
+    max?: number;
+    validator?: object;
+    validationLevel?: 'off' | 'strict' | 'moderate';
+    validationAction?: 'error' | 'warn';
+}
+interface CollectionInfo {
+    name: string;
+    type: 'collection';
+    options: Record<string, unknown>;
+    info: {
+        readOnly: boolean;
+    };
+}
+declare class MongoDatabase {
+    private readonly _databaseName;
+    private readonly collectionCache;
+    private readonly collections;
+    constructor(_client: MongoClient$1, name: string);
+    /**
+     * Get the database name
+     */
+    get databaseName(): string;
+    /**
+     * Get a collection instance
+     * @param name - Collection name
+     */
+    collection<TSchema extends Document = Document>(name: string): MongoCollection<TSchema>;
+    /**
+     * List all collections in the database
+     */
+    listCollections(filter?: {
+        name?: string;
+    }): ListCollectionsCursor;
+    /**
+     * Create a new collection
+     */
+    createCollection<TSchema extends Document = Document>(name: string, options?: CreateCollectionOptions): Promise<MongoCollection<TSchema>>;
+    /**
+     * Drop a collection
+     */
+    dropCollection(name: string): Promise<boolean>;
+    /**
+     * Drop the entire database
+     */
+    dropDatabase(): Promise<boolean>;
+    /**
+     * Get collection info for listing
+     * @internal
+     */
+    _getCollectionInfos(filter?: {
+        name?: string;
+    }): CollectionInfo[];
+    /**
+     * Register a collection (called by collection when data is first written)
+     * @internal
+     */
+    _registerCollection(name: string): void;
+}
+/**
+ * Cursor for listing collections
+ */
+declare class ListCollectionsCursor {
+    private readonly database;
+    private readonly filter?;
+    constructor(database: MongoDatabase, filter?: {
+        name?: string;
+    });
+    toArray(): Promise<CollectionInfo[]>;
+    forEach(callback: (info: CollectionInfo) => void): Promise<void>;
+}
+
+/**
+ * FindCursor - MongoDB-compatible cursor for query results
+ *
+ * Provides chainable methods for sorting, limiting, skipping, and projecting
+ * query results. Supports async iteration and array conversion.
+ */
+
+type Document$2 = Record<string, unknown>;
+interface FindOptions$1 {
+    projection?: Record<string, 0 | 1>;
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+    skip?: number;
+}
+/**
+ * FindCursor provides lazy evaluation of MongoDB queries
+ */
+declare class FindCursor<TSchema extends Document$2 = Document$2> {
+    private readonly collection;
+    private readonly filter;
+    private _projection?;
+    private _sort?;
+    private _limit?;
+    private _skip?;
+    private _executed;
+    private _results;
+    constructor(collection: MongoCollection<any>, filter: object, options?: FindOptions$1);
+    /**
+     * Set the sort order
+     */
+    sort(spec: Record<string, 1 | -1>): this;
+    /**
+     * Set the maximum number of documents to return
+     */
+    limit(count: number): this;
+    /**
+     * Set the number of documents to skip
+     */
+    skip(count: number): this;
+    /**
+     * Set the projection for returned documents
+     */
+    project(spec: Record<string, 0 | 1>): this;
+    /**
+     * Execute the query and return all documents as an array
+     */
+    toArray(): Promise<TSchema[]>;
+    /**
+     * Execute callback for each document
+     */
+    forEach(callback: (doc: TSchema) => void): Promise<void>;
+    /**
+     * Count documents matching the query
+     */
+    count(): Promise<number>;
+    /**
+     * Check if there are any documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get the next document (simple implementation)
+     */
+    next(): Promise<TSchema | null>;
+    /**
+     * Map over documents
+     */
+    map<U>(fn: (doc: TSchema) => U): MappedCursor<TSchema, U>;
+    /**
+     * Async iterator support
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TSchema>;
+}
+/**
+ * Cursor with map transformation applied
+ */
+declare class MappedCursor<TSchema extends Document$2, U> {
+    private readonly cursor;
+    private readonly mapFn;
+    constructor(cursor: FindCursor<TSchema>, mapFn: (doc: TSchema) => U);
+    toArray(): Promise<U[]>;
+    forEach(callback: (doc: U) => void): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<U>;
+}
+
+/**
+ * Bulk Write Operations - MongoDB-compatible bulk write support
+ *
+ * Provides types and utilities for bulk write operations that can
+ * batch multiple insert, update, and delete operations into a single
+ * request for improved performance.
+ */
+
+/**
+ * Base document type
+ */
+type Document$1 = Record<string, unknown>;
+/**
+ * Insert one operation in a bulk write
+ */
+interface InsertOneModel<TDocument extends Document$1 = Document$1> {
+    insertOne: {
+        document: TDocument;
+    };
+}
+/**
+ * Update one operation in a bulk write
+ */
+interface UpdateOneModel<TDocument extends Document$1 = Document$1> {
+    updateOne: {
+        filter: Partial<TDocument> | object;
+        update: object;
+        upsert?: boolean;
+        arrayFilters?: object[];
+        hint?: string | object;
+        collation?: object;
+    };
+}
+/**
+ * Update many operation in a bulk write
+ */
+interface UpdateManyModel<TDocument extends Document$1 = Document$1> {
+    updateMany: {
+        filter: Partial<TDocument> | object;
+        update: object;
+        upsert?: boolean;
+        arrayFilters?: object[];
+        hint?: string | object;
+        collation?: object;
+    };
+}
+/**
+ * Replace one operation in a bulk write
+ */
+interface ReplaceOneModel<TDocument extends Document$1 = Document$1> {
+    replaceOne: {
+        filter: object;
+        replacement: TDocument;
+        upsert?: boolean;
+        hint?: string | object;
+        collation?: object;
+    };
+}
+/**
+ * Delete one operation in a bulk write
+ */
+interface DeleteOneModel {
+    deleteOne: {
+        filter: object;
+        hint?: string | object;
+        collation?: object;
+    };
+}
+/**
+ * Delete many operation in a bulk write
+ */
+interface DeleteManyModel {
+    deleteMany: {
+        filter: object;
+        hint?: string | object;
+        collation?: object;
+    };
+}
+/**
+ * Union type of all bulk write operation models
+ */
+type BulkWriteOperation<TDocument extends Document$1 = Document$1> = InsertOneModel<TDocument> | UpdateOneModel<TDocument> | UpdateManyModel<TDocument> | ReplaceOneModel<TDocument> | DeleteOneModel | DeleteManyModel;
+/**
+ * Options for bulk write operations
+ */
+interface BulkWriteOptions {
+    /**
+     * If true (default), operations are executed in order.
+     * If an error occurs, remaining operations are not executed.
+     * If false, operations may be executed in any order, and all
+     * operations are attempted regardless of errors.
+     */
+    ordered?: boolean;
+    /**
+     * If true, bypass document validation during write operations
+     */
+    bypassDocumentValidation?: boolean;
+    /**
+     * Comment to attach to the operation
+     */
+    comment?: string | object;
+    /**
+     * Map of parameter names and values for use with $$var syntax
+     */
+    let?: Document$1;
+}
+/**
+ * Result of a bulk write operation
+ */
+interface BulkWriteResult {
+    /**
+     * Whether the write was acknowledged by the server
+     */
+    acknowledged: boolean;
+    /**
+     * Number of documents inserted
+     */
+    insertedCount: number;
+    /**
+     * Number of documents matched for update/replace operations
+     */
+    matchedCount: number;
+    /**
+     * Number of documents modified by update/replace operations
+     */
+    modifiedCount: number;
+    /**
+     * Number of documents deleted
+     */
+    deletedCount: number;
+    /**
+     * Number of documents upserted
+     */
+    upsertedCount: number;
+    /**
+     * Map of operation index to inserted document _id
+     */
+    insertedIds: Record<number, ObjectId$1 | string>;
+    /**
+     * Array of upserted document information
+     */
+    upsertedIds: Record<number, ObjectId$1 | string>;
+}
+
+/**
+ * ChangeStream - MongoDB-compatible change stream implementation
+ *
+ * Provides real-time notifications for data changes in a collection.
+ * Supports filtering with $match pipeline stages and resume tokens for
+ * reliable resumption after disconnections.
+ *
+ * @see https://www.mongodb.com/docs/manual/changeStreams/
+ */
+
+/**
+ * Change event operation types
+ */
+type OperationType = 'insert' | 'update' | 'replace' | 'delete' | 'drop' | 'invalidate';
+/**
+ * Namespace identifying the collection
+ */
+interface ChangeStreamNamespace {
+    db: string;
+    coll: string;
+}
+/**
+ * Document key identifying the changed document
+ */
+interface DocumentKey {
+    _id: ObjectId$1;
+}
+/**
+ * Description of fields updated/removed in an update operation
+ */
+interface UpdateDescription {
+    updatedFields: Record<string, unknown>;
+    removedFields: string[];
+    truncatedArrays?: Array<{
+        field: string;
+        newSize: number;
+    }>;
+}
+/**
+ * A change event emitted by the change stream
+ */
+interface ChangeEvent<TDocument = Record<string, unknown>> {
+    /** Resume token for this event */
+    _id: ResumeToken;
+    /** Type of operation that triggered this event */
+    operationType: OperationType;
+    /** Timestamp when the change occurred */
+    clusterTime: Date;
+    /** Database and collection namespace */
+    ns: ChangeStreamNamespace;
+    /** The _id of the affected document */
+    documentKey: DocumentKey;
+    /** Full document (for insert, replace, or update with fullDocument option) */
+    fullDocument?: TDocument;
+    /** Description of updated/removed fields (for update operations) */
+    updateDescription?: UpdateDescription;
+}
+/**
+ * Options for creating a change stream
+ */
+interface ChangeStreamOptions {
+    /** How to handle fullDocument for update operations */
+    fullDocument?: 'default' | 'updateLookup' | 'whenAvailable' | 'required';
+    /** Resume after this token (exclusive) */
+    resumeAfter?: ResumeToken;
+    /** Start after this token (exclusive) - similar to resumeAfter */
+    startAfter?: ResumeToken;
+    /** Start at a specific operation time */
+    startAtOperationTime?: Date;
+    /** Maximum time to wait for new events in ms */
+    maxAwaitTimeMS?: number;
+    /** Batch size for fetching events */
+    batchSize?: number;
+}
+/**
+ * Aggregation pipeline stage for filtering change events
+ */
+interface MatchStage {
+    $match: Record<string, unknown>;
+}
+type ChangeStreamPipeline = MatchStage[];
+/**
+ * Parsed resume token data
+ */
+interface ParsedResumeToken {
+    database: string;
+    collection: string;
+    sequence: number;
+    timestamp: number;
+}
+/**
+ * Resume token for resuming a change stream
+ */
+interface ResumeToken {
+    _data: string;
+}
+/**
+ * Utility class for generating and parsing resume tokens
+ */
+declare const ResumeToken: {
+    /**
+     * Generate a new resume token
+     */
+    generate(database: string, collection: string, sequence: number): ResumeToken;
+    /**
+     * Parse a resume token back to its components
+     */
+    parse(token: ResumeToken): ParsedResumeToken;
+    /**
+     * Compare two tokens for ordering
+     */
+    compare(a: ResumeToken, b: ResumeToken): number;
+};
+/**
+ * MongoDB-compatible change stream cursor
+ *
+ * Allows watching for changes on a collection in real-time.
+ * Supports filtering, resume tokens, and async iteration.
+ *
+ * @example
+ * ```typescript
+ * const changeStream = collection.watch([
+ *   { $match: { operationType: 'insert' } }
+ * ])
+ *
+ * for await (const event of changeStream) {
+ *   console.log('Change:', event.operationType, event.fullDocument)
+ * }
+ * ```
+ */
+declare class ChangeStream<TDocument = Record<string, unknown>> {
+    private readonly database;
+    private readonly collection;
+    private readonly pipeline;
+    private readonly options;
+    private readonly getDocumentById;
+    private readonly getChangeEvents;
+    private readonly onClose?;
+    private _closed;
+    private _resumeToken;
+    private _currentSequence;
+    private _pendingEvents;
+    constructor(database: string, collection: string, pipeline: ChangeStreamPipeline, options: ChangeStreamOptions, callbacks: {
+        getDocumentById: (id: ObjectId$1) => Promise<TDocument | null>;
+        getChangeEvents: (afterSequence: number) => Promise<StoredChangeEvent[]>;
+        getCurrentSequence: () => number;
+        onClose?: () => void;
+    });
+    /**
+     * Whether the change stream is closed
+     */
+    get closed(): boolean;
+    /**
+     * Get the current resume token (for the last received event)
+     */
+    getResumeToken(): ResumeToken | null;
+    /**
+     * Get the next change event (blocking)
+     * Returns null if the stream is closed
+     */
+    next(): Promise<ChangeEvent<TDocument> | null>;
+    /**
+     * Try to get the next event without blocking
+     * Returns null immediately if no events are available
+     */
+    tryNext(): Promise<ChangeEvent<TDocument> | null>;
+    /**
+     * Check if there are more events available
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Close the change stream
+     */
+    close(): Promise<void>;
+    /**
+     * Get a stream interface for the change stream
+     */
+    stream(): AsyncIterable<ChangeEvent<TDocument>>;
+    /**
+     * Async iterator implementation
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<ChangeEvent<TDocument>>;
+    /**
+     * Fetch new events from the change event store
+     */
+    private fetchNewEvents;
+    /**
+     * Transform a stored event into a ChangeEvent
+     */
+    private transformStoredEvent;
+    /**
+     * Check if an event matches the pipeline filters
+     */
+    private matchesPipeline;
+    /**
+     * Check if an event matches a $match condition
+     */
+    private matchesCondition;
+    /**
+     * Match a comparison operator
+     */
+    private matchesOperator;
+    /**
+     * Get a nested value from an object using dot notation
+     */
+    private getNestedValue;
+}
+/**
+ * Internal structure for stored change events
+ */
+interface StoredChangeEvent {
+    sequence: number;
+    operationType: OperationType;
+    documentId: string | ObjectId$1;
+    timestamp: number;
+    fullDocument?: Record<string, unknown>;
+    updatedFields?: Record<string, unknown>;
+    removedFields?: string[];
+}
+
+/**
+ * AggregationCursor - Async cursor for MongoDB aggregation pipeline results
+ *
+ * Provides:
+ * - Async iteration with for-await-of
+ * - toArray() for collecting all results
+ * - Support for async pipeline stages ($function, $lookup with pipeline)
+ * - Proper error propagation from async stages
+ */
+
+/**
+ * Options for aggregation cursor
+ */
+interface AggregationCursorOptions {
+    /** Batch size for streaming results */
+    batchSize?: number;
+    /** Allow disk use for large result sets */
+    allowDiskUse?: boolean;
+    /** Maximum time for operation (ms) */
+    maxTimeMS?: number;
+    /** Comment for the operation */
+    comment?: string;
+}
+/**
+ * Async function stage definition ($function)
+ */
+interface FunctionStage {
+    body: string | ((...args: unknown[]) => unknown | Promise<unknown>);
+    args: unknown[];
+    lang: 'js';
+}
+/**
+ * Executor function type for running pipeline against data
+ */
+type PipelineExecutor<T> = (documents: T[], stage: PipelineStage, context: AsyncExecutionContext) => Promise<T[]>;
+/**
+ * Context for async pipeline execution
+ */
+interface AsyncExecutionContext {
+    /** Collection name being aggregated */
+    collectionName: string;
+    /** Lookup function for $lookup stages */
+    lookupCollection?: (name: string) => Promise<Document[]>;
+    /** Custom function executor for $function stages */
+    functionExecutor?: (fn: FunctionStage, doc: Document) => Promise<unknown>;
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+}
+/**
+ * AggregationCursor provides async iteration over aggregation pipeline results
+ */
+declare class AggregationCursor<TSchema extends Document = Document> extends EventEmitter {
+    private readonly _pipeline;
+    private readonly _options;
+    private readonly _fetchFn;
+    private readonly _asyncExecutor;
+    private readonly _context;
+    private _buffer;
+    private _position;
+    private _fetched;
+    private _closed;
+    private _error;
+    /**
+     * Create a new AggregationCursor
+     *
+     * @param pipeline - The aggregation pipeline stages
+     * @param fetchFn - Function to fetch and execute the pipeline
+     * @param options - Cursor options
+     * @param asyncExecutor - Optional executor for async stages
+     * @param context - Execution context
+     */
+    constructor(pipeline: PipelineStage[], fetchFn: () => Promise<TSchema[]>, options?: AggregationCursorOptions, asyncExecutor?: PipelineExecutor<TSchema>, context?: AsyncExecutionContext);
+    /**
+     * Whether the cursor is closed
+     */
+    get closed(): boolean;
+    /**
+     * Get the pipeline being executed
+     */
+    get pipeline(): PipelineStage[];
+    /**
+     * Number of documents currently buffered
+     */
+    get bufferedCount(): number;
+    /**
+     * Execute the pipeline and fetch results
+     */
+    private ensureFetched;
+    /**
+     * Check if pipeline contains async stages
+     */
+    private hasAsyncStages;
+    /**
+     * Check if $lookup stage requires async execution
+     */
+    private isAsyncLookup;
+    /**
+     * Execute async stages in the pipeline
+     */
+    private executeAsyncStages;
+    /**
+     * Execute $function stage
+     */
+    private executeFunctionStage;
+    /**
+     * Execute $lookup with pipeline (async)
+     */
+    private executeAsyncLookup;
+    /**
+     * Get nested value from document
+     */
+    private getNestedValue;
+    /**
+     * Check if two values are equal
+     */
+    private valuesEqual;
+    /**
+     * Check if document matches an expression (simplified)
+     */
+    private matchesExpression;
+    /**
+     * Evaluate $expr
+     */
+    private evaluateExpr;
+    /**
+     * Evaluate a comparison operator
+     */
+    private evaluateOperator;
+    /**
+     * Get the next document
+     */
+    next(): Promise<TSchema | null>;
+    /**
+     * Check if there are more documents
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Get all documents as an array
+     */
+    toArray(): Promise<TSchema[]>;
+    /**
+     * Execute callback for each document
+     */
+    forEach(callback: (doc: TSchema, index: number) => void | false | Promise<void | false>): Promise<void>;
+    /**
+     * Transform documents
+     */
+    map<U>(fn: (doc: TSchema, index: number) => U): MappedAggregationCursor<TSchema, U>;
+    /**
+     * Close the cursor
+     */
+    close(): Promise<void>;
+    /**
+     * Async iterator support for for-await-of
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<TSchema>;
+    /**
+     * Clone the cursor
+     */
+    clone(): AggregationCursor<TSchema>;
+    /**
+     * Explain the aggregation plan
+     */
+    explain(): AggregationPlan;
+    /**
+     * Check if a stage is async
+     */
+    private isAsyncStage;
+}
+/**
+ * Mapped cursor for transformed results
+ */
+declare class MappedAggregationCursor<TSchema extends Document, U> {
+    private readonly _cursor;
+    private readonly _mapFn;
+    constructor(cursor: AggregationCursor<TSchema>, mapFn: (doc: TSchema, index: number) => U);
+    toArray(): Promise<U[]>;
+    forEach(callback: (doc: U, index: number) => void | false | Promise<void | false>): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<U>;
+}
+/**
+ * Aggregation plan interface
+ */
+interface AggregationPlan {
+    pipeline: Array<{
+        stage: string;
+        isAsync: boolean;
+    }>;
+    hasAsyncStages: boolean;
+    options: AggregationCursorOptions;
+}
+
+/**
+ * MongoCollection - MongoDB-compatible collection interface
+ *
+ * Provides CRUD operations and query support for documents.
+ * This is the client-side in-memory implementation for testing.
+ */
+
+type Document = Record<string, unknown>;
+interface InsertOneResult {
+    acknowledged: boolean;
+    insertedId: ObjectId$1;
+}
+interface InsertManyResult {
+    acknowledged: boolean;
+    insertedCount: number;
+    insertedIds: Record<number, ObjectId$1>;
+}
+interface UpdateResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedId?: ObjectId$1;
+    upsertedCount?: number;
+}
+interface DeleteResult {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+interface SessionOption {
+    session?: ClientSession;
+}
+interface FindOptions extends SessionOption {
+    projection?: Record<string, 0 | 1> | undefined;
+    sort?: Record<string, 1 | -1> | undefined;
+    limit?: number | undefined;
+    skip?: number | undefined;
+}
+interface InsertOneOptions extends SessionOption {
+}
+interface InsertManyOptions extends SessionOption {
+}
+interface UpdateOptions extends SessionOption {
+    upsert?: boolean | undefined;
+    arrayFilters?: object[] | undefined;
+}
+interface ReplaceOptions extends SessionOption {
+    upsert?: boolean | undefined;
+}
+interface DeleteOptions extends SessionOption {
+}
+interface FindOneAndUpdateOptions extends SessionOption {
+    projection?: Record<string, 0 | 1> | undefined;
+    sort?: Record<string, 1 | -1> | undefined;
+    upsert?: boolean | undefined;
+    returnDocument?: 'before' | 'after' | undefined;
+}
+interface FindOneAndDeleteOptions extends SessionOption {
+    projection?: Record<string, 0 | 1> | undefined;
+    sort?: Record<string, 1 | -1> | undefined;
+}
+interface FindOneAndReplaceOptions extends SessionOption {
+    projection?: Record<string, 0 | 1> | undefined;
+    sort?: Record<string, 1 | -1> | undefined;
+    upsert?: boolean | undefined;
+    returnDocument?: 'before' | 'after' | undefined;
+}
+/**
+ * MongoCollection provides CRUD operations for documents
+ */
+declare class MongoCollection<TSchema extends Document = Document> implements TransactableCollection {
+    private readonly database;
+    private readonly _collectionName;
+    private documents;
+    private readonly _changeEventStore;
+    private readonly _activeChangeStreams;
+    constructor(database: MongoDatabase, name: string);
+    /**
+     * Get the collection name
+     */
+    get collectionName(): string;
+    /**
+     * Ensure collection is created in the database
+     * @internal
+     */
+    _ensureCreated(): Promise<void>;
+    /**
+     * Drop collection data
+     * @internal
+     */
+    _drop(): Promise<void>;
+    /**
+     * Get a unique key for this collection (used for transaction tracking)
+     * @internal
+     */
+    _getCollectionKey(): string;
+    /**
+     * Create a snapshot of the current collection data
+     * @internal
+     */
+    _createSnapshot(): Map<string, Record<string, unknown>>;
+    /**
+     * Restore collection data from a snapshot (used for transaction rollback)
+     * @internal
+     */
+    _restoreFromSnapshot(snapshot: Map<string, Record<string, unknown>>): void;
+    /**
+     * Track this collection in a session for transaction support
+     * @internal
+     */
+    private _trackInSession;
+    /**
+     * Insert a single document
+     */
+    insertOne(doc: TSchema, options?: InsertOneOptions): Promise<InsertOneResult>;
+    /**
+     * Insert multiple documents
+     */
+    insertMany(docs: TSchema[], options?: InsertManyOptions): Promise<InsertManyResult>;
+    /**
+     * Find a single document
+     */
+    findOne(filter?: object, options?: FindOptions): Promise<(TSchema & {
+        _id: ObjectId$1;
+    }) | null>;
+    /**
+     * Find multiple documents, returns a cursor
+     */
+    find(filter?: object, options?: FindOptions): FindCursor<TSchema & {
+        _id: ObjectId$1;
+    }>;
+    /**
+     * Internal method to execute find query
+     * @internal
+     */
+    _findDocuments(filter: object, options?: {
+        sort?: Record<string, 1 | -1>;
+        skip?: number;
+        limit?: number;
+    }): (TSchema & {
+        _id: ObjectId$1;
+    })[];
+    /**
+     * Update a single document
+     */
+    updateOne(filter: object, update: object, options?: UpdateOptions): Promise<UpdateResult>;
+    /**
+     * Update multiple documents
+     */
+    updateMany(filter: object, update: object, options?: UpdateOptions): Promise<UpdateResult>;
+    /**
+     * Replace a single document
+     */
+    replaceOne(filter: object, replacement: TSchema, options?: ReplaceOptions): Promise<UpdateResult>;
+    /**
+     * Delete a single document
+     */
+    deleteOne(filter: object, options?: DeleteOptions): Promise<DeleteResult>;
+    /**
+     * Delete multiple documents
+     */
+    deleteMany(filter: object, options?: DeleteOptions): Promise<DeleteResult>;
+    /**
+     * Count documents matching filter
+     */
+    countDocuments(filter?: object): Promise<number>;
+    /**
+     * Find one and update
+     */
+    findOneAndUpdate(filter: object, update: object, options?: FindOneAndUpdateOptions): Promise<(TSchema & {
+        _id: ObjectId$1;
+    }) | null>;
+    /**
+     * Find one and delete
+     */
+    findOneAndDelete(filter: object, options?: FindOneAndDeleteOptions): Promise<(TSchema & {
+        _id: ObjectId$1;
+    }) | null>;
+    /**
+     * Find one and replace
+     */
+    findOneAndReplace(filter: object, replacement: TSchema, options?: FindOneAndReplaceOptions): Promise<(TSchema & {
+        _id: ObjectId$1;
+    }) | null>;
+    /**
+     * Execute multiple write operations in a single batch
+     *
+     * @param operations - Array of bulk write operations
+     * @param options - Bulk write options
+     * @returns BulkWriteResult with operation counts
+     */
+    bulkWrite(operations: BulkWriteOperation<TSchema>[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
+    /**
+     * Drop the collection
+     */
+    drop(): Promise<boolean>;
+    /**
+     * Watch for changes on this collection
+     *
+     * Creates a change stream that emits events for insert, update, replace, and delete operations.
+     *
+     * @param pipeline - Optional aggregation pipeline for filtering events (supports $match)
+     * @param options - Change stream options
+     * @returns A ChangeStream instance
+     *
+     * @example
+     * ```typescript
+     * const changeStream = collection.watch([
+     *   { $match: { operationType: 'insert' } }
+     * ])
+     *
+     * for await (const event of changeStream) {
+     *   console.log('Change:', event.operationType, event.fullDocument)
+     * }
+     * ```
+     */
+    watch(pipeline?: ChangeStreamPipeline, options?: ChangeStreamOptions): ChangeStream<TSchema>;
+    /**
+     * Check if a document matches a filter
+     * @internal
+     */
+    private _matchesFilter;
+    /**
+     * Check if a value matches operator conditions
+     */
+    private _matchesOperators;
+    /**
+     * Compare two values for equality
+     */
+    private _valuesEqual;
+    /**
+     * Get nested value from document using dot notation
+     */
+    private _getNestedValue;
+    /**
+     * Apply update operators to a document
+     */
+    private _applyUpdate;
+    /**
+     * Set a nested value in an object
+     */
+    private _setNestedValue;
+    /**
+     * Delete a nested value from an object
+     */
+    private _deleteNestedValue;
+    /**
+     * Sort documents by the given sort specification
+     */
+    private _sortDocuments;
+    /**
+     * Apply projection to a document
+     * @internal
+     */
+    _applyProjection(doc: TSchema & {
+        _id: ObjectId$1;
+    }, projection: Record<string, 0 | 1>): TSchema & {
+        _id: ObjectId$1;
+    };
+    /**
+     * Extract updated and removed fields from an update object
+     * @internal
+     */
+    private _extractUpdateChanges;
+    /**
+     * Execute an aggregation pipeline on the collection
+     *
+     * Returns an AggregationCursor that supports:
+     * - Async iteration with `for await (const doc of cursor)`
+     * - Converting to array with `await cursor.toArray()`
+     * - forEach iteration with `await cursor.forEach(callback)`
+     *
+     * Supports async stages like $function and $lookup with pipeline.
+     *
+     * @param pipeline - Array of aggregation pipeline stages
+     * @param options - Aggregation options
+     * @returns AggregationCursor for iterating over results
+     *
+     * @example
+     * ```typescript
+     * // Using toArray
+     * const results = await collection.aggregate([
+     *   { $match: { status: 'active' } },
+     *   { $group: { _id: '$category', count: { $sum: 1 } } }
+     * ]).toArray()
+     *
+     * // Using async iterator
+     * for await (const doc of collection.aggregate([
+     *   { $match: { status: 'active' } }
+     * ])) {
+     *   console.log(doc)
+     * }
+     * ```
+     */
+    aggregate<TResult extends Document = TSchema>(pipeline: PipelineStage[], options?: AggregationCursorOptions): AggregationCursor<TResult>;
+    /**
+     * Execute $function stage on a document
+     * @internal
+     */
+    private _executeFunctionStage;
+    /**
+     * Execute aggregation pipeline on documents (in-memory implementation)
+     * @internal
+     */
+    private _executeAggregationPipeline;
+    /**
+     * Execute $project stage
+     * @internal
+     */
+    private _executeProjectStage;
+    /**
+     * Execute $group stage
+     * @internal
+     */
+    private _executeGroupStage;
+    /**
+     * Execute $sort stage
+     * @internal
+     */
+    private _executeSortStage;
+    /**
+     * Execute $unwind stage
+     * @internal
+     */
+    private _executeUnwindStage;
+    /**
+     * Execute $addFields/$set stage
+     * @internal
+     */
+    private _executeAddFieldsStage;
+    /**
+     * Execute $lookup stage
+     * @internal
+     */
+    private _executeLookupStage;
+    /**
+     * Evaluate an expression (simplified)
+     * @internal
+     */
+    private _evaluateExpression;
+    /**
+     * Evaluate a condition
+     * @internal
+     */
+    private _evaluateCondition;
+    /**
+     * Compare two expression values
+     * @internal
+     */
+    private _compareExprValues;
+}
+
+/**
+ * RPC Client - Client-side RPC handler for capnweb-style Workers RPC
+ *
+ * Implements:
+ * - HTTP batch protocol
+ * - WebSocket sessions
+ * - Auto-reconnection
+ * - Request deduplication
+ */
+
+/**
+ * Deduplicates identical concurrent requests
+ */
+declare class RequestDeduplicator {
+    private cache;
+    private ttl;
+    private cleanupInterval;
+    constructor(options?: DeduplicatorOptions);
+    /**
+     * Start the cleanup interval
+     */
+    private startCleanup;
+    /**
+     * Stop the cleanup interval
+     */
+    destroy(): void;
+    /**
+     * Clean up expired entries
+     */
+    private cleanup;
+    /**
+     * Check if a key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Get a cached promise
+     */
+    get(key: string): Promise<unknown> | undefined;
+    /**
+     * Set a promise for a key
+     */
+    set(key: string, promise: Promise<unknown>): void;
+    /**
+     * Generate a cache key from method and params
+     */
+    static generateKey(method: string, params: unknown[]): string;
+}
+/**
+ * WebSocket-based RPC transport
+ */
+declare class WebSocketRpcTransport {
+    private ws;
+    private messageId;
+    private pending;
+    private messageHandlers;
+    private options;
+    constructor(ws: WebSocket, options?: {
+        timeout?: number;
+    });
+    /**
+     * Set up the WebSocket message handler
+     */
+    private setupMessageHandler;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Send a request over WebSocket
+     */
+    send(request: Omit<RpcRequest, 'id'>): Promise<unknown>;
+    /**
+     * Add a message handler for streaming responses
+     */
+    onMessage(handler: (message: unknown) => void): () => void;
+    /**
+     * Close the connection
+     */
+    close(): void;
+    /**
+     * Get connection state
+     */
+    get readyState(): number;
+}
+/**
+ * RPC client for connecting to Mondo workers
+ */
+declare class RpcClient {
+    private url;
+    readonly options: Required<RpcClientOptions>;
+    readonly transport: 'http' | 'websocket';
+    private eventHandlers;
+    private batchMode;
+    private batchQueue;
+    private deduplicator;
+    private wsTransport;
+    constructor(url: string, options?: RpcClientOptions);
+    /**
+     * Make an RPC call
+     */
+    call(method: string, params: unknown[]): Promise<unknown>;
+    /**
+     * Execute the actual RPC call
+     */
+    private executeCall;
+    /**
+     * Execute with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Start batch mode
+     */
+    startBatch(): void;
+    /**
+     * End batch mode and send all queued requests
+     */
+    endBatch(): Promise<void>;
+    /**
+     * Register an event handler
+     */
+    on<T = unknown>(event: string, handler: EventHandler<T>): void;
+    /**
+     * Remove an event handler
+     */
+    off<T = unknown>(event: string, handler: EventHandler<T>): void;
+    /**
+     * Emit an event
+     */
+    emit<T = unknown>(event: string, data: T): void;
+    /**
+     * Connect via WebSocket
+     */
+    connectWebSocket(): Promise<void>;
+    /**
+     * Close the client connection
+     */
+    close(): void;
+}
+/**
+ * MongoDB-compatible client wrapper over RPC
+ */
+declare class MongoClient {
+    private client;
+    private isConnected;
+    private dbName;
+    constructor(url: string, options?: RpcClientOptions);
+    /**
+     * Parse MongoDB URL to extract RPC endpoint
+     */
+    private parseMongoUrl;
+    /**
+     * Connect to the database
+     */
+    connect(): Promise<MongoClient>;
+    /**
+     * Get a database reference
+     */
+    db(name?: string): Database;
+    /**
+     * Close the connection
+     */
+    close(): void;
+    /**
+     * Check if connected
+     */
+    get connected(): boolean;
+}
+/**
+ * Database reference
+ */
+declare class Database {
+    private client;
+    private name;
+    constructor(client: RpcClient, name: string);
+    /**
+     * Get a collection reference
+     */
+    collection(name: string): Collection;
+}
+/**
+ * RPC Find Cursor - Simple cursor for RPC-based find operations
+ */
+declare class RpcFindCursor<T = unknown> {
+    private client;
+    private dbName;
+    private collectionName;
+    private query;
+    private _sort?;
+    private _limit?;
+    private _skip?;
+    private _projection?;
+    private _buffer;
+    private _position;
+    private _fetched;
+    private _closed;
+    constructor(client: RpcClient, dbName: string, collectionName: string, query?: Record<string, unknown>);
+    get closed(): boolean;
+    sort(spec: Record<string, 1 | -1>): this;
+    limit(count: number): this;
+    skip(count: number): this;
+    project(spec: Record<string, 0 | 1>): this;
+    private ensureFetched;
+    next(): Promise<T | null>;
+    hasNext(): Promise<boolean>;
+    toArray(): Promise<T[]>;
+    forEach(callback: (doc: T, index: number) => void | false | Promise<void | false>): Promise<void>;
+    count(): Promise<number>;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+/**
+ * RPC Aggregation Cursor - Simple cursor for RPC-based aggregate operations
+ */
+declare class RpcAggregationCursor<T = unknown> {
+    private client;
+    private dbName;
+    private collectionName;
+    private pipeline;
+    private options;
+    private _buffer;
+    private _position;
+    private _fetched;
+    private _closed;
+    constructor(client: RpcClient, dbName: string, collectionName: string, pipeline?: unknown[], options?: Record<string, unknown>);
+    get closed(): boolean;
+    private ensureFetched;
+    next(): Promise<T | null>;
+    hasNext(): Promise<boolean>;
+    toArray(): Promise<T[]>;
+    forEach(callback: (doc: T, index: number) => void | false | Promise<void | false>): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+/**
+ * Collection reference
+ */
+declare class Collection {
+    private client;
+    private dbName;
+    private collectionName;
+    constructor(client: RpcClient, dbName: string, collectionName: string);
+    /**
+     * Find documents - returns a cursor
+     */
+    find(query?: Record<string, unknown>): RpcFindCursor;
+    /**
+     * Find one document
+     */
+    findOne(query?: Record<string, unknown>): Promise<unknown | null>;
+    /**
+     * Aggregate pipeline - returns a cursor
+     */
+    aggregate(pipeline?: unknown[], options?: Record<string, unknown>): RpcAggregationCursor;
+    /**
+     * Insert one document
+     */
+    insertOne(document: Record<string, unknown>): Promise<{
+        insertedId: string;
+    }>;
+    /**
+     * Update one document
+     */
+    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    /**
+     * Delete one document
+     */
+    deleteOne(filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+}
+
+export { CreateIndexOptions, CreateIndexResult, DeduplicatorOptions, DropIndexResult, EventHandler, IndexInfo, IndexManager, IndexSpec, MongoClient, MongoCollection, ObjectId$1 as ObjectId, RequestDeduplicator, RpcClient, RpcClientOptions, RpcRequest, SQLStorage, WebSocketRpcTransport, buildCreateIndexSQL, generateIndexName, generateSQLiteIndexName };