mongo.do 0.1.0 → 0.1.1

package/dist/worker-entrypoint-BEW23Gmp.d.ts

@@ -0,0 +1,1331 @@
+/**
+ * ObjectId - MongoDB-compatible 12-byte unique identifier
+ *
+ * Structure (12 bytes = 24 hex characters):
+ * - 4 bytes: Unix timestamp (seconds since epoch)
+ * - 5 bytes: Random value (generated once per process)
+ * - 3 bytes: Incrementing counter (initialized to random value)
+ *
+ * Compatible with MongoDB BSON ObjectId specification.
+ */
+/**
+ * Type guard for ObjectId-like values
+ */
+type ObjectIdLike = ObjectId | string | Uint8Array;
+/**
+ * Input types accepted by ObjectId constructor
+ */
+type ObjectIdInput = ObjectIdLike | null | undefined;
+/**
+ * ObjectId class - MongoDB-compatible unique identifier
+ *
+ * @example
+ * ```typescript
+ * // Generate new ObjectId
+ * const id = new ObjectId()
+ *
+ * // Create from hex string
+ * const id2 = ObjectId.createFromHexString('507f1f77bcf86cd799439011')
+ *
+ * // Get timestamp
+ * const timestamp = id.getTimestamp()
+ *
+ * // Compare ObjectIds
+ * id.equals(id2) // false
+ * ```
+ */
+declare class ObjectId {
+    /** BSON type identifier for serialization compatibility */
+    readonly _bsontype: "ObjectId";
+    /** The raw 12-byte buffer containing the ObjectId data */
+    readonly id: Uint8Array;
+    /** Cached hex string representation (computed lazily) */
+    private _hexString;
+    /**
+     * Create a new ObjectId
+     *
+     * @param input - Optional: hex string, Uint8Array, or another ObjectId.
+     *                If omitted, generates a new unique ObjectId.
+     * @throws {TypeError} If input is invalid
+     */
+    constructor(input?: ObjectIdInput);
+    /**
+     * Generate a new 12-byte ObjectId buffer
+     * Structure: 4-byte timestamp | 5-byte random | 3-byte counter
+     */
+    private generate;
+    /**
+     * Get the timestamp component of this ObjectId as a Date
+     *
+     * @returns Date object representing when this ObjectId was generated
+     */
+    getTimestamp(): Date;
+    /**
+     * Get the generation time as Unix timestamp (seconds)
+     */
+    getGenerationTime(): number;
+    /**
+     * Return the ObjectId as a 24-character lowercase hex string
+     */
+    toHexString(): string;
+    /**
+     * String representation of the ObjectId (same as toHexString)
+     */
+    toString(): string;
+    /**
+     * JSON serialization - returns hex string
+     * This allows ObjectIds to serialize naturally in JSON.stringify()
+     */
+    toJSON(): string;
+    /**
+     * Compare this ObjectId to another value for equality
+     *
+     * @param other - ObjectId, hex string, or null/undefined to compare
+     * @returns true if the ObjectIds are equal, false otherwise
+     */
+    equals(other: ObjectId | string | null | undefined): boolean;
+    /**
+     * Primitive value conversion (returns hex string)
+     */
+    valueOf(): string;
+    /**
+     * Symbol.toStringTag for better debugging output
+     */
+    get [Symbol.toStringTag](): string;
+    /**
+     * Create an ObjectId from a 24-character hex string
+     *
+     * @param hexString - 24-character hex string
+     * @returns New ObjectId instance
+     * @throws {TypeError} If hexString is invalid
+     */
+    static createFromHexString(hexString: string): ObjectId;
+    /**
+     * Create an ObjectId with a specific timestamp
+     * Useful for range queries on _id fields
+     *
+     * @param time - Unix timestamp in seconds
+     * @returns New ObjectId with the given timestamp and zeroed remaining bytes
+     */
+    static createFromTime(time: number): ObjectId;
+    /**
+     * Generate a new ObjectId (factory method, equivalent to new ObjectId())
+     *
+     * @returns New unique ObjectId instance
+     */
+    static generate(): ObjectId;
+    /**
+     * Check if a value is a valid ObjectId or ObjectId hex string
+     *
+     * @param value - Value to check
+     * @returns true if valid ObjectId or 24-char hex string
+     */
+    static isValid(value: unknown): value is ObjectId | string;
+    /**
+     * Check if a string is a valid 24-character hex string
+     */
+    private static isValidHex;
+}
+
+/**
+ * Consolidated RPC Types
+ *
+ * This module contains all shared RPC-related type definitions used across:
+ * - src/rpc/rpc-target.ts
+ * - src/rpc/rpc-client.ts
+ * - src/rpc/endpoint.ts
+ * - src/rpc/index.ts
+ * - src/wire/backend/workers-proxy.ts
+ */
+/**
+ * Durable Object namespace interface
+ */
+interface DurableObjectNamespace {
+    idFromName(name: string): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub;
+}
+/**
+ * Durable Object ID interface
+ */
+interface DurableObjectId {
+    toString(): string;
+}
+/**
+ * Durable Object stub interface
+ */
+interface DurableObjectStub {
+    fetch(request: Request | string, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Base Mondo environment bindings interface
+ */
+interface MondoEnv {
+    MONDO_DATABASE: DurableObjectNamespace;
+    /** Optional Worker Loader for $function support (closed beta) */
+    LOADER?: WorkerLoader;
+    /** Optional auth token for RPC endpoint */
+    MONDO_AUTH_TOKEN?: string;
+}
+/**
+ * Worker Loader interface for dynamic worker creation
+ * (Closed beta feature for $function operator support)
+ */
+interface WorkerLoader {
+    get(id: string, getCode: () => Promise<WorkerCode>): WorkerStub;
+}
+/**
+ * Worker code specification for dynamic workers
+ */
+interface WorkerCode {
+    compatibilityDate: string;
+    compatibilityFlags?: string[];
+    mainModule: string;
+    modules: Record<string, string | {
+        js: string;
+    } | {
+        text: string;
+    }>;
+    globalOutbound?: null;
+    env?: Record<string, unknown>;
+}
+/**
+ * Worker stub interface for dynamic workers
+ */
+interface WorkerStub {
+    fetch?(request: Request): Promise<Response>;
+    getEntrypoint?(name?: string): WorkerEntrypoint$1;
+}
+/**
+ * Worker entrypoint interface
+ */
+interface WorkerEntrypoint$1 {
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * RPC request structure for Workers RPC (capnweb-style)
+ * Used by rpc-target.ts and rpc-client.ts
+ */
+interface RpcRequest {
+    id?: string;
+    method: string;
+    params: unknown[];
+}
+/**
+ * RPC response structure for Workers RPC
+ */
+interface RpcResponse {
+    id?: string;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Batch response structure
+ */
+interface BatchResponse {
+    results: RpcResponse[];
+}
+/**
+ * RPC request structure for HTTP endpoint
+ * Used by endpoint.ts and workers-proxy.ts
+ */
+interface HttpRpcRequest {
+    method: string;
+    db?: string;
+    collection?: string;
+    filter?: Record<string, unknown>;
+    update?: Record<string, unknown>;
+    document?: Record<string, unknown>;
+    documents?: Record<string, unknown>[];
+    pipeline?: Record<string, unknown>[];
+    options?: Record<string, unknown>;
+    field?: string;
+    query?: Record<string, unknown>;
+}
+/**
+ * HTTP RPC success response
+ */
+interface HttpRpcSuccessResponse {
+    ok: 1;
+    result: unknown;
+}
+/**
+ * HTTP RPC error response
+ */
+interface HttpRpcErrorResponse {
+    ok: 0;
+    error: string;
+    code: number;
+    codeName?: string;
+}
+/**
+ * HTTP RPC response (union type)
+ */
+type HttpRpcResponse = HttpRpcSuccessResponse | HttpRpcErrorResponse;
+/**
+ * RPC message types for internal operations
+ */
+declare enum MessageType {
+    INSERT_ONE = "insertOne",
+    INSERT_MANY = "insertMany",
+    FIND_ONE = "findOne",
+    FIND = "find",
+    UPDATE_ONE = "updateOne",
+    UPDATE_MANY = "updateMany",
+    DELETE_ONE = "deleteOne",
+    DELETE_MANY = "deleteMany",
+    AGGREGATE = "aggregate",
+    COUNT = "count",
+    DISTINCT = "distinct",
+    CREATE_INDEX = "createIndex",
+    DROP_INDEX = "dropIndex",
+    LIST_INDEXES = "listIndexes",
+    CREATE_COLLECTION = "createCollection",
+    DROP_COLLECTION = "dropCollection",
+    LIST_COLLECTIONS = "listCollections",
+    STATS = "stats",
+    HEALTH = "health"
+}
+/**
+ * Legacy RPC request interface (message-based)
+ */
+interface LegacyRpcRequest {
+    type: MessageType;
+    collection?: string;
+    payload: unknown;
+}
+/**
+ * Legacy RPC response interface
+ */
+interface LegacyRpcResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Database reference returned by db() method
+ */
+interface DatabaseRef {
+    name: string;
+    stub: DurableObjectStub;
+}
+/**
+ * Collection reference returned by collection() method
+ */
+interface CollectionRef {
+    dbName: string;
+    collectionName: string;
+    stub: DurableObjectStub;
+}
+/**
+ * Batched executor options
+ */
+interface BatchedExecutorOptions {
+    maxBatchSize?: number;
+    flushInterval?: number;
+}
+/**
+ * Pipelined operation reference
+ */
+interface PipelineOp {
+    id: string;
+    method: string;
+    params: unknown[];
+    dependencies: string[];
+}
+/**
+ * RPC client options
+ */
+interface RpcClientOptions {
+    /** Enable automatic reconnection */
+    autoReconnect?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Reconnect interval in milliseconds */
+    reconnectInterval?: number;
+    /** Enable request deduplication */
+    deduplicate?: boolean;
+    /** Deduplication TTL in milliseconds */
+    deduplicationTtl?: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Options for request deduplicator
+ */
+interface DeduplicatorOptions {
+    ttl?: number;
+}
+/**
+ * Event handler type
+ */
+type EventHandler<T = unknown> = (event: T) => void;
+/**
+ * Reconnect event data
+ */
+interface ReconnectEvent {
+    attempt: number;
+    lastError?: Error;
+}
+/**
+ * RPC Handler interface
+ */
+interface RpcHandler {
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * MongoDB-compatible error codes
+ */
+declare const ErrorCode: {
+    readonly OK: 0;
+    readonly INTERNAL_ERROR: 1;
+    readonly BAD_VALUE: 2;
+    readonly NO_SUCH_KEY: 4;
+    readonly GRAPH_CONTAINS_CYCLE: 5;
+    readonly HOST_UNREACHABLE: 6;
+    readonly HOST_NOT_FOUND: 7;
+    readonly UNKNOWN_ERROR: 8;
+    readonly FAILED_TO_PARSE: 9;
+    readonly CANNOT_MUTATE_OBJECT: 10;
+    readonly USER_NOT_FOUND: 11;
+    readonly UNSUPPORTED_FORMAT: 12;
+    readonly UNAUTHORIZED: 13;
+    readonly TYPE_MISMATCH: 14;
+    readonly OVERFLOW: 15;
+    readonly INVALID_LENGTH: 16;
+    readonly PROTOCOL_ERROR: 17;
+    readonly AUTHENTICATION_FAILED: 18;
+    readonly CANNOT_REUSE_OBJECT: 19;
+    readonly ILLEGAL_OPERATION: 20;
+    readonly EMPTY_ARRAY_OPERATION: 21;
+    readonly INVALID_BSON: 22;
+    readonly ALREADY_INITIALIZED: 23;
+    readonly LOCK_TIMEOUT: 24;
+    readonly REMOTE_VALIDATION_ERROR: 25;
+    readonly NAMESPACE_NOT_FOUND: 26;
+    readonly INDEX_NOT_FOUND: 27;
+    readonly PATH_NOT_VIABLE: 28;
+    readonly NON_EXISTENT_PATH: 29;
+    readonly INVALID_PATH: 30;
+    readonly ROLE_NOT_FOUND: 31;
+    readonly ROLES_NOT_RELATED: 32;
+    readonly PRIVILEGE_NOT_FOUND: 33;
+    readonly CANNOT_BACKFILL_ARRAY: 34;
+    readonly COMMAND_NOT_FOUND: 59;
+    readonly DATABASE_NOT_FOUND: 60;
+    readonly LOCATION_ERROR: 16755;
+    readonly DUPLICATE_KEY: 11000;
+};
+type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * Get the code name for an error code
+ */
+declare function getErrorCodeName(code: number): string;
+/**
+ * Create a success response (Document format for wire protocol)
+ */
+declare function successResponse(data?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Create an error response (Document format for wire protocol)
+ */
+declare function errorResponse(code: number, errmsg: string, codeName?: string): Record<string, unknown>;
+/**
+ * Create a legacy success response
+ */
+declare function legacySuccessResponse<T>(data: T): LegacyRpcResponse<T>;
+/**
+ * Create a legacy error response
+ */
+declare function legacyErrorResponse(code: string, message: string): LegacyRpcResponse<never>;
+
+/**
+ * Index specification type
+ * Keys are field names, values are 1 (ascending), -1 (descending), or 'text' for text indexes
+ */
+type IndexSpec = Record<string, 1 | -1 | 'text'>;
+/**
+ * Options for creating an index
+ */
+interface CreateIndexOptions {
+    /** Name of the index (auto-generated if not provided) */
+    name?: string;
+    /** Create a unique index */
+    unique?: boolean;
+    /** Create a sparse index (only index documents with the field) */
+    sparse?: boolean;
+    /** Create index in background */
+    background?: boolean;
+    /** Partial filter expression for partial indexes */
+    partialFilterExpression?: Record<string, unknown>;
+    /** TTL in seconds for TTL indexes */
+    expireAfterSeconds?: number;
+    /** Weights for text index fields (higher weight = more important) */
+    weights?: Record<string, number>;
+    /** Default language for text index */
+    default_language?: string;
+    /** Field containing document language override */
+    language_override?: string;
+}
+/**
+ * Result from createIndex operation
+ */
+interface CreateIndexResult {
+    ok: 1;
+    numIndexesBefore: number;
+    numIndexesAfter: number;
+    createdCollectionAutomatically: boolean;
+    note?: string;
+}
+/**
+ * Index information returned by listIndexes
+ */
+interface IndexInfo {
+    /** Index name */
+    name: string;
+    /** Index key specification */
+    key: IndexSpec;
+    /** Version (always 2 for SQLite backed indexes) */
+    v: number;
+    /** Whether this is a unique index */
+    unique?: boolean;
+    /** Whether this is a sparse index */
+    sparse?: boolean;
+    /** Partial filter expression */
+    partialFilterExpression?: Record<string, unknown>;
+    /** TTL in seconds */
+    expireAfterSeconds?: number;
+    /** Weights for text index fields */
+    weights?: Record<string, number>;
+    /** Default language for text index */
+    default_language?: string;
+    /** Whether this is a text index */
+    textIndexVersion?: number;
+}
+/**
+ * Result from dropIndex operation
+ */
+interface DropIndexResult {
+    ok: 1;
+    nIndexesWas: number;
+}
+/**
+ * Document type - any JSON-serializable object with optional _id
+ */
+interface Document {
+    _id?: string | ObjectId;
+    [key: string]: unknown;
+}
+/**
+ * Insert result
+ */
+interface InsertOneResult {
+    acknowledged: boolean;
+    insertedId: string;
+}
+/**
+ * Delete result
+ */
+interface DeleteResult {
+    acknowledged: boolean;
+    deletedCount: number;
+}
+/**
+ * Update result
+ */
+interface UpdateResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    /** Number of documents upserted (only present when upsert: true was used) */
+    upsertedCount?: number;
+    /** ID of the upserted document (only present when a document was upserted) */
+    upsertedId?: string;
+}
+
+/**
+ * SQLite Schema Management for MondoDB
+ *
+ * This module handles the initialization and management of SQLite tables
+ * for MongoDB-compatible document storage in Cloudflare Durable Objects.
+ *
+ * UNIFIED SCHEMA TYPES:
+ * This module serves as the single source of truth for all schema-related types
+ * used by both IndexManager and MondoDatabase.
+ */
+
+/**
+ * Current schema version - derived from migrations module
+ */
+declare const SCHEMA_VERSION: number;
+/**
+ * Table definitions for the schema (exported for reference/testing)
+ *
+ * UNIFIED SCHEMA: This schema supports both MondoDatabase and IndexManager:
+ * - collections table: stores collection metadata including indexes JSON
+ * - documents table: stores documents with _id as the document identifier
+ *
+ * Note: The actual table creation is handled by migrations.ts.
+ * These definitions are kept in sync for reference and testing.
+ */
+declare const SCHEMA_TABLES: {
+    readonly collections: {
+        readonly name: "collections";
+        readonly sql: string;
+    };
+    readonly documents: {
+        readonly name: "documents";
+        readonly sql: string;
+    };
+};
+/**
+ * Interface for SQL query result with parameter binding
+ * Used by MondoDatabase with Cloudflare's native SQL interface
+ */
+interface SqlQueryResult {
+    toArray(): unknown[];
+    run(): void;
+    bind(...params: unknown[]): SqlQueryResult;
+}
+/**
+ * Interface for Cloudflare Durable Object SQL storage
+ * Used by MondoDatabase for direct SQL execution
+ */
+interface SqlStorage {
+    exec(sql: string, ...params: unknown[]): SqlQueryResult;
+}
+/**
+ * Interface for Cloudflare Durable Object storage
+ * Used by MondoDatabase and SchemaManager
+ */
+interface DurableObjectStorage {
+    sql: SqlStorage;
+    get<T>(key: string): Promise<T | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    /**
+     * Execute a synchronous callback wrapped in a transaction.
+     * If the callback throws, the transaction is rolled back.
+     * Only available for SQLite-backed Durable Objects.
+     */
+    transactionSync<T>(callback: () => T): T;
+}
+/**
+ * Interface for SQL prepared statement
+ * Used by IndexManager for prepared statement execution
+ */
+interface SQLStatement {
+    bind(...params: unknown[]): SQLStatement;
+    run(): void;
+    first<T = unknown>(): T | null;
+    all<T = unknown>(): T[];
+}
+/**
+ * Interface for SQLite-compatible storage with SQL execution
+ * Used by IndexManager for prepared statement-based operations
+ *
+ * This is an alternative interface to DurableObjectStorage that provides
+ * a prepare() method for creating prepared statements, which is useful
+ * for operations that need to retrieve results or bind parameters.
+ */
+interface SQLStorage {
+    exec(sql: string): void;
+    prepare(sql: string): SQLStatement;
+}
+/**
+ * TTL Index information with collection context
+ */
+interface TTLIndexInfo {
+    collectionName: string;
+    collectionId: number;
+    indexName: string;
+    field: string;
+    expireAfterSeconds: number;
+}
+/**
+ * TTL metadata for tracking cleanup operations
+ */
+interface TTLMetadata {
+    field: string;
+    expireAfterSeconds: number;
+    lastCleanupAt?: string;
+    lastCleanupCount?: number;
+}
+/**
+ * Result of a TTL cleanup operation
+ */
+interface TTLCleanupResult {
+    ok: 1;
+    collectionsProcessed: number;
+    documentsDeleted: number;
+    errors?: string[];
+}
+/**
+ * Query info for deleting expired documents
+ */
+interface ExpiredDocumentsQuery {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * Schema validation result
+ */
+interface SchemaValidationResult {
+    valid: boolean;
+    missingTables: string[];
+    missingIndexes: string[];
+    errors: string[];
+}
+/**
+ * SchemaManager handles SQLite schema initialization and migrations
+ */
+declare class SchemaManager {
+    private storage;
+    constructor(storage: DurableObjectStorage);
+    /**
+     * Initialize the schema, running migrations if needed
+     */
+    initializeSchema(): Promise<void>;
+    /**
+     * Validate that the schema is properly initialized
+     * Returns true if all required tables exist
+     */
+    validateSchema(): Promise<boolean>;
+    /**
+     * Detailed schema validation with specific error information
+     */
+    validateSchemaDetailed(): Promise<SchemaValidationResult>;
+    /**
+     * Get the current schema version from storage
+     */
+    getSchemaVersion(): Promise<number>;
+    /**
+     * Check if schema needs migration
+     */
+    needsMigration(): Promise<boolean>;
+    /**
+     * Get list of pending migrations
+     */
+    getPendingMigrations(): Promise<number[]>;
+}
+
+/**
+ * Types for aggregation pipeline stages
+ */
+
+type PipelineStage = {
+    $match: Record<string, unknown>;
+} | {
+    $project: Record<string, unknown>;
+} | {
+    $group: GroupStage;
+} | {
+    $sort: Record<string, 1 | -1>;
+} | {
+    $limit: number;
+} | {
+    $skip: number;
+} | {
+    $count: string;
+} | {
+    $lookup: LookupStage;
+} | {
+    $unwind: string | UnwindStage;
+} | {
+    $addFields: Record<string, unknown>;
+} | {
+    $bucket: BucketStage;
+} | {
+    $facet: Record<string, PipelineStage[]>;
+} | {
+    $search: SearchStage;
+} | {
+    $vectorSearch: VectorSearchPipelineStage;
+};
+interface SearchStage {
+    index?: string;
+    text?: {
+        query: string;
+        path?: string | string[];
+    };
+    phrase?: {
+        query: string;
+        path?: string | string[];
+    };
+    wildcard?: {
+        query: string;
+        path?: string | string[];
+    };
+    compound?: {
+        must?: SearchStage[];
+        should?: SearchStage[];
+        mustNot?: SearchStage[];
+        filter?: SearchStage[];
+    };
+}
+interface GroupStage {
+    _id: null | string | Record<string, string>;
+    [accumulator: string]: unknown;
+}
+interface LookupStage {
+    from: string;
+    localField?: string;
+    foreignField?: string;
+    as: string;
+    let?: Record<string, string>;
+    pipeline?: PipelineStage[];
+}
+interface UnwindStage {
+    path: string;
+    includeArrayIndex?: string;
+    preserveNullAndEmptyArrays?: boolean;
+}
+interface BucketStage {
+    groupBy: string;
+    boundaries: number[];
+    default?: string;
+    output?: Record<string, unknown>;
+}
+/**
+ * $vectorSearch pipeline stage for vector similarity search
+ * Compatible with MongoDB Atlas vector search
+ */
+interface VectorSearchPipelineStage {
+    /** Name of the vector search index */
+    index: string;
+    /** Path to the vector field in documents */
+    path: string;
+    /** The query vector to search for */
+    queryVector: number[];
+    /** Number of candidates to consider (default: limit * 10) */
+    numCandidates?: number;
+    /** Maximum number of results to return */
+    limit: number;
+    /** Optional filter to apply before vector search */
+    filter?: Record<string, unknown>;
+    /** Whether to perform exact search (slower but more accurate) */
+    exact?: boolean;
+    /** Field name to store the similarity score (default: 'score') */
+    scoreField?: string;
+}
+
+/**
+ * MondoDatabase - MongoDB-compatible Durable Object
+ *
+ * This is the main Durable Object class that provides MongoDB-compatible
+ * operations backed by Cloudflare's SQLite storage.
+ */
+
+/**
+ * Interface for Durable Object state
+ */
+interface DurableObjectState {
+    storage: DurableObjectStorage;
+    blockConcurrencyWhile<T>(callback: () => Promise<T>): void;
+}
+/**
+ * Interface for Cloudflare Environment bindings
+ */
+interface Env {
+    /** Optional worker-loader binding for $function support */
+    LOADER?: WorkerLoader;
+    /** Enable debug endpoints (/internal/reset, /internal/dump) - DO NOT enable in production */
+    ENABLE_DEBUG_ENDPOINTS?: string;
+}
+/**
+ * Result of an insertMany operation
+ * Note: This uses string[] for insertedIds (matching MongoDB's native driver behavior),
+ * while the shared InsertManyResult type uses Record<number, string> for MongoDB compatibility
+ */
+interface InsertManyResult {
+    acknowledged: boolean;
+    insertedCount: number;
+    insertedIds: string[];
+}
+/**
+ * MondoDatabase Durable Object
+ *
+ * Provides MongoDB-compatible document storage using Cloudflare Durable Objects
+ * with SQLite as the backing store.
+ */
+declare class MondoDatabase {
+    private state;
+    private env;
+    private schemaManager;
+    private initialized;
+    private mcpHandler;
+    constructor(state: DurableObjectState, env: Env);
+    /**
+     * Check if the database is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get the schema manager for advanced operations
+     */
+    getSchemaManager(): SchemaManager;
+    /**
+     * Get the underlying storage
+     */
+    getStorage(): DurableObjectStorage;
+    /**
+     * Get or create a collection by name, returning the collection_id
+     */
+    private getOrCreateCollection;
+    /**
+     * Get collection ID by name, returns undefined if not found
+     */
+    private getCollectionId;
+    /**
+     * Insert a single document into a collection
+     */
+    insertOne(collection: string, document: Document): Promise<InsertOneResult>;
+    /**
+     * Insert multiple documents into a collection
+     */
+    insertMany(collection: string, documents: Document[]): Promise<InsertManyResult>;
+    /**
+     * Find a single document matching the query
+     */
+    findOne(collection: string, query?: Document): Promise<Document | null>;
+    /**
+     * Find all documents matching the query
+     */
+    find(collection: string, query?: Document): Promise<Document[]>;
+    /**
+     * Update a single document matching the filter
+     */
+    updateOne(collection: string, filter: Document, update: {
+        $set?: Document;
+        $unset?: Record<string, unknown>;
+    }): Promise<UpdateResult>;
+    /**
+     * Delete a single document matching the filter
+     */
+    deleteOne(collection: string, filter: Document): Promise<DeleteResult>;
+    /**
+     * Build WHERE clause from MongoDB-style query
+     * Supports: _id, simple field equality, $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $exists
+     */
+    private buildWhereClause;
+    /**
+     * Convert a field name (possibly with dot notation) to JSON path
+     * e.g., "profile.level" -> "$.profile.level"
+     */
+    private fieldToJsonPath;
+    /**
+     * Set a nested value in an object using dot notation path
+     */
+    private setNestedValue;
+    /**
+     * Delete a nested value from an object using dot notation path
+     */
+    private deleteNestedValue;
+    /**
+     * Delete multiple documents matching the filter
+     */
+    deleteMany(collection: string, filter?: Document): Promise<DeleteResult>;
+    /**
+     * Count documents matching the filter
+     */
+    countDocuments(collection: string, filter?: Document): Promise<number>;
+    /**
+     * Execute an aggregation pipeline on a collection
+     *
+     * Supports async execution for $function operators that require
+     * JavaScript execution via worker-loader.
+     *
+     * @param collection - The collection name
+     * @param pipeline - Array of aggregation pipeline stages
+     * @returns Array of result documents
+     */
+    aggregate(collection: string, pipeline: PipelineStage[]): Promise<unknown[]>;
+    /**
+     * Reset database - for testing purposes
+     */
+    private reset;
+    /**
+     * Dump database contents - for debugging
+     */
+    private dump;
+    /**
+     * Handle incoming fetch requests
+     * Implements HTTP API for MongoDB-compatible operations
+     */
+    fetch(request: Request): Promise<Response>;
+}
+
+/**
+ * RPC Target - Server-side RPC handler for capnweb-style Workers RPC
+ *
+ * Implements:
+ * - MondoRpcTarget extending RpcTarget base class
+ * - Request routing to Durable Object stubs
+ * - HTTP batch protocol support
+ * - Promise pipelining for chained operations
+ */
+
+/**
+ * Base class for RPC targets (capnweb-style)
+ */
+declare class RpcTarget {
+    protected methods: Map<string, (...args: unknown[]) => Promise<unknown>>;
+    /**
+     * Allowlist of methods that can be invoked via RPC.
+     * Subclasses should override this to define their allowed methods.
+     * This prevents invocation of inherited methods like constructor, __proto__, toString, etc.
+     */
+    protected allowedMethods: Set<string>;
+    /**
+     * Register a method handler
+     */
+    protected registerMethod(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+    /**
+     * Check if a method exists and is allowed
+     */
+    hasMethod(name: string): boolean;
+    /**
+     * Invoke a method by name
+     */
+    invoke(method: string, params: unknown[]): Promise<unknown>;
+}
+/**
+ * MondoRpcTarget provides MongoDB-compatible API via Workers RPC
+ */
+declare class MondoRpcTarget extends RpcTarget {
+    private env;
+    private currentConnectionString;
+    private databases;
+    /**
+     * Explicit allowlist of methods that can be invoked via RPC.
+     * This prevents invocation of inherited methods like constructor, __proto__, toString, etc.
+     */
+    protected allowedMethods: Set<string>;
+    constructor(env: MondoEnv);
+    /**
+     * Connect to a MongoDB-compatible connection string
+     */
+    connect(connectionString: string): Promise<{
+        connected: boolean;
+        database?: string;
+    }>;
+    /**
+     * Get the current connection string
+     */
+    get connectionString(): string | null;
+    /**
+     * Get a database reference
+     */
+    db(name: string): Promise<DatabaseRef>;
+    /**
+     * Get a collection reference
+     */
+    collection(dbName: string, collectionName: string): Promise<CollectionRef>;
+    /**
+     * Execute a find operation
+     */
+    find(dbName: string, collectionName: string, query: Record<string, unknown>): Promise<unknown[]>;
+    /**
+     * Execute an insertOne operation
+     */
+    insertOne(dbName: string, collectionName: string, document: Record<string, unknown>): Promise<{
+        insertedId: string;
+    }>;
+    /**
+     * Execute an updateOne operation
+     */
+    updateOne(dbName: string, collectionName: string, filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    /**
+     * Execute a deleteOne operation
+     */
+    deleteOne(dbName: string, collectionName: string, filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+}
+/**
+ * Create a Workers RPC response from a target and request
+ */
+declare function newWorkersRpcResponse(target: RpcTarget, request: Request): Promise<Response>;
+/**
+ * Batched RPC executor that coalesces multiple requests
+ */
+declare class BatchedRpcExecutor {
+    private stub;
+    private options;
+    private queue;
+    private flushTimer;
+    constructor(stub: DurableObjectStub, options?: BatchedExecutorOptions);
+    /**
+     * Execute a method with batching
+     */
+    execute(method: string, params: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Flush pending requests
+     */
+    flush(): Promise<void>;
+}
+/**
+ * Pipeline tracker for chained operations
+ */
+declare class PipelineTracker {
+    private operations;
+    private dependencyGraph;
+    /**
+     * Track a new operation
+     */
+    track(method: string, params: unknown[], dependency?: string): string;
+    /**
+     * Get all dependencies for an operation
+     */
+    getDependencies(opId: string): string[];
+    /**
+     * Get operation by ID
+     */
+    getOperation(opId: string): PipelineOp | undefined;
+    /**
+     * Get all operations in dependency order
+     */
+    getOrderedOperations(): PipelineOp[];
+}
+/**
+ * Pipelined RPC proxy for chained method calls
+ */
+declare class PipelinedRpcProxy {
+    private target;
+    private tracker;
+    private currentDb;
+    private currentCollection;
+    constructor(target: MondoRpcTarget);
+    /**
+     * Get a database reference (pipelined)
+     */
+    db(name: string): PipelinedDbProxy;
+    /**
+     * Execute the pipelined operations
+     */
+    execute(): Promise<unknown>;
+    /**
+     * Get the underlying target
+     */
+    getTarget(): MondoRpcTarget;
+    /**
+     * Get current database name
+     */
+    getCurrentDb(): string | null;
+    /**
+     * Get current collection name
+     */
+    getCurrentCollection(): string | null;
+    /**
+     * Set current collection
+     */
+    setCurrentCollection(name: string): void;
+}
+/**
+ * Pipelined database proxy
+ */
+declare class PipelinedDbProxy {
+    private parent;
+    private dbName;
+    private operationId;
+    constructor(parent: PipelinedRpcProxy, dbName: string, opId: string);
+    /**
+     * Get the operation ID
+     */
+    get opId(): string;
+    /**
+     * Get a collection reference (pipelined)
+     */
+    collection(name: string): PipelinedCollectionProxy;
+}
+/**
+ * Pipelined collection proxy
+ */
+declare class PipelinedCollectionProxy {
+    private parent;
+    private dbName;
+    private collectionName;
+    constructor(parent: PipelinedRpcProxy, dbName: string, collectionName: string);
+    /**
+     * Find documents (executes the pipeline)
+     */
+    find(query: Record<string, unknown>): Promise<unknown[]>;
+    /**
+     * 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;
+    }>;
+}
+
+/**
+ * Worker Entrypoint - Workers RPC service binding support
+ *
+ * Implements:
+ * - MondoEntrypoint extending WorkerEntrypoint
+ * - Service binding methods
+ * - TypeScript declarations
+ * - Environment safety
+ */
+
+/**
+ * Execution context interface
+ */
+interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/**
+ * Mondo bindings interface (for service binding consumers)
+ */
+interface MondoBindings {
+    /** Connect to a MongoDB-compatible connection string */
+    connect(connectionString: string): Promise<{
+        connected: boolean;
+        database?: string;
+    }>;
+    /** Get a database reference */
+    db(name: string): Promise<DatabaseRef>;
+    /** Get a collection reference */
+    collection(dbName: string, collectionName: string): Promise<CollectionRef>;
+}
+/**
+ * Default options for the entrypoint
+ */
+declare const DEFAULT_OPTIONS: {
+    /** Maximum batch size for batched operations */
+    readonly maxBatchSize: 100;
+    /** Request timeout in milliseconds */
+    readonly timeout: 30000;
+    /** Enable background cleanup */
+    readonly enableCleanup: true;
+    /** Cleanup interval in milliseconds */
+    readonly cleanupInterval: 60000;
+};
+/**
+ * Entrypoint options
+ */
+interface MondoEntrypointOptions {
+    maxBatchSize?: number;
+    timeout?: number;
+    enableCleanup?: boolean;
+    cleanupInterval?: number;
+}
+/**
+ * Base class for Worker entrypoints (capnweb-style)
+ */
+declare class WorkerEntrypoint {
+    protected ctx: ExecutionContext;
+    protected env: unknown;
+    constructor(ctx: ExecutionContext, env: unknown);
+    /**
+     * Handle HTTP fetch requests
+     */
+    fetch(_request: Request): Promise<Response>;
+}
+/**
+ * Type guard for Mondo environment
+ */
+declare function isMondoEnv(env: unknown): env is MondoEnv;
+/**
+ * Validate environment bindings
+ */
+declare function validateEnv(env: unknown): boolean;
+/**
+ * MondoEntrypoint extends WorkerEntrypoint for service binding support
+ *
+ * Usage in wrangler.toml:
+ * ```toml
+ * [[services]]
+ * binding = "MONDO"
+ * service = "mongo.do"
+ * entrypoint = "MondoEntrypoint"
+ * ```
+ *
+ * Usage in consuming worker:
+ * ```typescript
+ * const result = await env.MONDO.connect('mongodb://localhost/mydb');
+ * ```
+ */
+declare class MondoEntrypoint extends WorkerEntrypoint implements MondoBindings {
+    protected env: MondoEnv;
+    private rpcTarget;
+    private entrypointOptions;
+    private cleanupScheduled;
+    constructor(ctx: ExecutionContext, env: MondoEnv);
+    /**
+     * Get the entrypoint options
+     */
+    get options(): Required<MondoEntrypointOptions>;
+    /**
+     * Handle HTTP fetch requests
+     */
+    fetch(request: Request): Promise<Response>;
+    /**
+     * Connect to a MongoDB-compatible connection string
+     */
+    connect(connectionString: string): Promise<{
+        connected: boolean;
+        database?: string;
+    }>;
+    /**
+     * Get a database reference
+     */
+    db(name: string): Promise<DatabaseRef>;
+    /**
+     * Get a collection reference
+     */
+    collection(dbName: string, collectionName: string): Promise<CollectionRef>;
+    /**
+     * Execute a find operation
+     */
+    find(dbName: string, collectionName: string, query: Record<string, unknown>): Promise<unknown[]>;
+    /**
+     * Execute an insertOne operation
+     */
+    insertOne(dbName: string, collectionName: string, document: Record<string, unknown>): Promise<{
+        insertedId: string;
+    }>;
+    /**
+     * Execute an updateOne operation
+     */
+    updateOne(dbName: string, collectionName: string, filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    /**
+     * Execute a deleteOne operation
+     */
+    deleteOne(dbName: string, collectionName: string, filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+    /**
+     * Schedule background cleanup task
+     */
+    scheduleCleanup(): void;
+    /**
+     * Run cleanup task
+     */
+    private runCleanup;
+    /**
+     * Get the underlying RPC target (for testing)
+     */
+    getRpcTarget(): MondoRpcTarget;
+}
+
+export { type ErrorCodeValue as $, type WorkerStub as A, type WorkerEntrypoint$1 as B, type CreateIndexOptions as C, type DropIndexResult as D, type ExecutionContext as E, type RpcResponse as F, type BatchResponse as G, type HttpRpcRequest as H, type IndexInfo as I, type HttpRpcSuccessResponse as J, type HttpRpcErrorResponse as K, type HttpRpcResponse as L, type MondoEnv as M, type LegacyRpcRequest as N, ObjectId as O, type PipelineStage as P, type LegacyRpcResponse as Q, type RpcClientOptions as R, type SQLStorage as S, type TTLIndexInfo as T, type DatabaseRef as U, type CollectionRef as V, WorkerEntrypoint as W, type BatchedExecutorOptions as X, type PipelineOp as Y, type ReconnectEvent as Z, type RpcHandler as _, MondoEntrypoint as a, RpcTarget as a0, MondoRpcTarget as a1, newWorkersRpcResponse as a2, BatchedRpcExecutor as a3, PipelineTracker as a4, PipelinedRpcProxy as a5, validateEnv as a6, isMondoEnv as a7, DEFAULT_OPTIONS as a8, type MondoBindings as a9, type MondoEntrypointOptions as aa, MondoDatabase as b, type IndexSpec as c, type CreateIndexResult as d, type ExpiredDocumentsQuery as e, type TTLMetadata as f, type TTLCleanupResult as g, type EventHandler as h, type RpcRequest as i, type DeduplicatorOptions as j, SchemaManager as k, SCHEMA_VERSION as l, SCHEMA_TABLES as m, type SQLStatement as n, ErrorCode as o, getErrorCodeName as p, errorResponse as q, legacySuccessResponse as r, successResponse as s, legacyErrorResponse as t, MessageType as u, type DurableObjectNamespace as v, type DurableObjectId as w, type DurableObjectStub as x, type WorkerLoader as y, type WorkerCode as z };