@objectstack/spec 0.3.1 → 0.3.3

package/dist/driver/driver.zod.d.ts

@@ -0,0 +1,3392 @@
+import { z } from 'zod';
+/**
+ * Common Driver Options
+ * Passed to most driver methods to control behavior (transactions, timeouts, etc.)
+ */
+export declare const DriverOptionsSchema: z.ZodObject<{
+    /**
+     * Transaction handle/identifier.
+     * If provided, the operation must run within this transaction.
+     */
+    transaction: z.ZodOptional<z.ZodAny>;
+    /**
+     * Operation timeout in milliseconds.
+     */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Whether to bypass cache and force a fresh read.
+     */
+    skipCache: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Distributed Tracing Context.
+     * Used for passing OpenTelemetry span context or request IDs for observability.
+     */
+    traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Tenant Identifier.
+     * For multi-tenant databases (row-level security or schema-per-tenant).
+     */
+    tenantId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number | undefined;
+    tenantId?: string | undefined;
+    transaction?: any;
+    skipCache?: boolean | undefined;
+    traceContext?: Record<string, string> | undefined;
+}, {
+    timeout?: number | undefined;
+    tenantId?: string | undefined;
+    transaction?: any;
+    skipCache?: boolean | undefined;
+    traceContext?: Record<string, string> | undefined;
+}>;
+/**
+ * Driver Capabilities Schema
+ *
+ * Defines what features a database driver supports.
+ * This allows ObjectQL to adapt its behavior based on underlying database capabilities.
+ */
+export declare const DriverCapabilitiesSchema: z.ZodObject<{
+    /**
+     * Whether the driver supports database transactions.
+     * If true, beginTransaction, commit, and rollback must be implemented.
+     */
+    transactions: z.ZodBoolean;
+    /**
+     * Whether the driver supports WHERE clause filters.
+     * If false, ObjectQL will fetch all records and filter in memory.
+     *
+     * Example: Memory driver might not support complex filter conditions.
+     */
+    queryFilters: z.ZodBoolean;
+    /**
+     * Whether the driver supports aggregation functions (COUNT, SUM, AVG, etc.).
+     * If false, ObjectQL will compute aggregations in memory.
+     */
+    queryAggregations: z.ZodBoolean;
+    /**
+     * Whether the driver supports ORDER BY sorting.
+     * If false, ObjectQL will sort results in memory.
+     */
+    querySorting: z.ZodBoolean;
+    /**
+     * Whether the driver supports LIMIT/OFFSET pagination.
+     * If false, ObjectQL will fetch all records and paginate in memory.
+     */
+    queryPagination: z.ZodBoolean;
+    /**
+     * Whether the driver supports window functions (ROW_NUMBER, RANK, LAG, LEAD, etc.).
+     * If false, ObjectQL will compute window functions in memory.
+     */
+    queryWindowFunctions: z.ZodBoolean;
+    /**
+     * Whether the driver supports subqueries (nested SELECT statements).
+     * If false, ObjectQL will execute queries separately and combine results.
+     */
+    querySubqueries: z.ZodBoolean;
+    /**
+     * Whether the driver supports SQL-style joins.
+     * If false, ObjectQL will fetch related data separately and join in memory.
+     */
+    joins: z.ZodBoolean;
+    /**
+     * Whether the driver supports full-text search.
+     * If true, text search queries can be pushed to the database.
+     */
+    fullTextSearch: z.ZodBoolean;
+    /**
+     * Whether the driver supports JSON field types.
+     * If false, JSON data will be serialized as strings.
+     */
+    jsonFields: z.ZodBoolean;
+    /**
+     * Whether the driver supports array field types.
+     * If false, arrays will be stored as JSON strings or in separate tables.
+     */
+    arrayFields: z.ZodBoolean;
+    /**
+     * Whether the driver supports vector embeddings and similarity search.
+     * Required for RAG (Retrieval-Augmented Generation) and AI features.
+     */
+    vectorSearch: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Whether the driver supports geospatial queries.
+     */
+    geoSpatial: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    joins: boolean;
+    transactions: boolean;
+    queryFilters: boolean;
+    queryAggregations: boolean;
+    querySorting: boolean;
+    queryPagination: boolean;
+    queryWindowFunctions: boolean;
+    querySubqueries: boolean;
+    fullTextSearch: boolean;
+    jsonFields: boolean;
+    arrayFields: boolean;
+    vectorSearch: boolean;
+    geoSpatial: boolean;
+}, {
+    joins: boolean;
+    transactions: boolean;
+    queryFilters: boolean;
+    queryAggregations: boolean;
+    querySorting: boolean;
+    queryPagination: boolean;
+    queryWindowFunctions: boolean;
+    querySubqueries: boolean;
+    fullTextSearch: boolean;
+    jsonFields: boolean;
+    arrayFields: boolean;
+    vectorSearch?: boolean | undefined;
+    geoSpatial?: boolean | undefined;
+}>;
+/**
+ * Unified Database Driver Interface
+ *
+ * This is the contract that all storage adapters (Postgres, Mongo, Excel, Salesforce) must implement.
+ * It abstracts the underlying engine, enabling ObjectStack to be "Database Agnostic".
+ */
+export declare const DriverInterfaceSchema: z.ZodObject<{
+    /**
+     * Driver name (e.g., 'postgresql', 'mongodb', 'rest_api').
+     */
+    name: z.ZodString;
+    /**
+     * Driver version.
+     */
+    version: z.ZodString;
+    /**
+     * Capabilities descriptor.
+     */
+    supports: z.ZodObject<{
+        /**
+         * Whether the driver supports database transactions.
+         * If true, beginTransaction, commit, and rollback must be implemented.
+         */
+        transactions: z.ZodBoolean;
+        /**
+         * Whether the driver supports WHERE clause filters.
+         * If false, ObjectQL will fetch all records and filter in memory.
+         *
+         * Example: Memory driver might not support complex filter conditions.
+         */
+        queryFilters: z.ZodBoolean;
+        /**
+         * Whether the driver supports aggregation functions (COUNT, SUM, AVG, etc.).
+         * If false, ObjectQL will compute aggregations in memory.
+         */
+        queryAggregations: z.ZodBoolean;
+        /**
+         * Whether the driver supports ORDER BY sorting.
+         * If false, ObjectQL will sort results in memory.
+         */
+        querySorting: z.ZodBoolean;
+        /**
+         * Whether the driver supports LIMIT/OFFSET pagination.
+         * If false, ObjectQL will fetch all records and paginate in memory.
+         */
+        queryPagination: z.ZodBoolean;
+        /**
+         * Whether the driver supports window functions (ROW_NUMBER, RANK, LAG, LEAD, etc.).
+         * If false, ObjectQL will compute window functions in memory.
+         */
+        queryWindowFunctions: z.ZodBoolean;
+        /**
+         * Whether the driver supports subqueries (nested SELECT statements).
+         * If false, ObjectQL will execute queries separately and combine results.
+         */
+        querySubqueries: z.ZodBoolean;
+        /**
+         * Whether the driver supports SQL-style joins.
+         * If false, ObjectQL will fetch related data separately and join in memory.
+         */
+        joins: z.ZodBoolean;
+        /**
+         * Whether the driver supports full-text search.
+         * If true, text search queries can be pushed to the database.
+         */
+        fullTextSearch: z.ZodBoolean;
+        /**
+         * Whether the driver supports JSON field types.
+         * If false, JSON data will be serialized as strings.
+         */
+        jsonFields: z.ZodBoolean;
+        /**
+         * Whether the driver supports array field types.
+         * If false, arrays will be stored as JSON strings or in separate tables.
+         */
+        arrayFields: z.ZodBoolean;
+        /**
+         * Whether the driver supports vector embeddings and similarity search.
+         * Required for RAG (Retrieval-Augmented Generation) and AI features.
+         */
+        vectorSearch: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Whether the driver supports geospatial queries.
+         */
+        geoSpatial: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch: boolean;
+        geoSpatial: boolean;
+    }, {
+        joins: boolean;
+        transactions: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch?: boolean | undefined;
+        geoSpatial?: boolean | undefined;
+    }>;
+    /**
+     * Initialize connection pool or authenticate.
+     */
+    connect: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Close connections and cleanup resources.
+     */
+    disconnect: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Check connection health.
+     * @returns true if healthy, false otherwise.
+     */
+    checkHealth: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodBoolean>>;
+    /**
+     * Get Connection Pool Statistics.
+     * Useful for monitoring database load.
+     */
+    getPoolStats: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        idle: z.ZodNumber;
+        active: z.ZodNumber;
+        waiting: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        active: number;
+        total: number;
+        idle: number;
+        waiting: number;
+    }, {
+        active: number;
+        total: number;
+        idle: number;
+        waiting: number;
+    }>>>>;
+    /**
+     * Execute a raw command/query native to the driver.
+     * Useful for complex reports, stored procedures, or DDL not covered by standard sync.
+     *
+     * @param command - The raw command (e.g., SQL string, shell command, or remote API payload).
+     * @param parameters - Optional array of bound parameters for safe execution (prevention of injection).
+     * @param options - Driver options (transaction context, timeout).
+     * @returns Promise resolving to the raw result from the driver.
+     *
+     * @example
+     * // SQL Driver
+     * await driver.execute('SELECT * FROM complex_view WHERE id = ?', [123]);
+     *
+     * // Mongo Driver
+     * await driver.execute({ aggregate: 'orders', pipeline: [...] });
+     */
+    execute: z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodOptional<z.ZodArray<z.ZodAny, "many">>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    /**
+     * Find multiple records matching the structured query.
+     * Parsing the QueryAST is the responsibility of the driver implementation.
+     *
+     * @param object - The name of the object/table to query (e.g. 'account').
+     * @param query - The structured QueryAST (filters, sorts, joins, pagination).
+     * @param options - Driver options.
+     * @returns Array of records.
+     *
+     * @example
+     * await driver.find('account', {
+     *   filters: [['status', '=', 'active'], 'and', ['amount', '>', 500]],
+     *   sort: [{ field: 'created_at', order: 'desc' }],
+     *   top: 10
+     * });
+     * @returns Array of records.
+     *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
+     */
+    find: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    /**
+     * Stream records matching the structured query.
+     * Optimized for large datasets to avoid memory overflow.
+     *
+     * @param object - The name of the object.
+     * @param query - The structured QueryAST.
+     * @param options - Driver options.
+     * @returns AsyncIterable/ReadableStream of records.
+     */
+    findStream: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodAny>;
+    /**
+     * Find a single record by query.
+     * Similar to find(), but returns only the first match or null.
+     *
+     * @param object - The name of the object.
+     * @param query - QueryAST.
+     * @param options - Driver options.
+     * @returns The record or null.
+     *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
+     */
+    findOne: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    /**
+     * Create a new record.
+     *
+     * @param object - The object name.
+     * @param data - Key-value map of field data.
+     * @param options - Driver options.
+     * @returns The created record, including server-generated fields (id, created_at, etc.).
+     *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
+     */
+    create: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    /**
+     * Update an existing record by ID.
+     *
+     * @param object - The object name.
+     * @param id - The unique identifier of the record.
+     * @param data - The fields to update.
+     * @param options - Driver options.
+     * @returns The updated record.
+     *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
+     */
+    update: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    /**
+     * Upsert (Update or Insert) a record.
+     *
+     * @param object - The object name.
+     * @param data - The data to upsert.
+     * @param conflictKeys - Fields to check for conflict (uniqueness).
+     * @param options - Driver options.
+     * @returns The created or updated record.
+     */
+    upsert: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodArray<z.ZodString, "many">>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    /**
+     * Delete a record by ID.
+     *
+     * @param object - The object name.
+     * @param id - The unique identifier of the record.
+     * @param options - Driver options.
+     * @returns True if deleted, false if not found.
+     */
+    delete: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodBoolean>>;
+    /**
+     * Count records matching a query.
+     *
+     * @param object - The object name.
+     * @param query - Optional filtering criteria.
+     * @param options - Driver options.
+     * @returns Total count.
+     */
+    count: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNumber>>;
+    /**
+     * Create multiple records in a single batch.
+     * Optimized for performance.
+     *
+     * @param object - The object name.
+     * @param dataArray - Array of record data.
+     * @returns Array of created records.
+     */
+    bulkCreate: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    /**
+     * Update multiple records in a single batch.
+     *
+     * @param object - The object name.
+     * @param updates - Array of objects containing {id, data}.
+     * @returns Array of updated records.
+     */
+    bulkUpdate: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodObject<{
+        id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        id: string | number;
+        data: Record<string, any>;
+    }, {
+        id: string | number;
+        data: Record<string, any>;
+    }>, "many">, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    /**
+     * Delete multiple records in a single batch.
+     *
+     * @param object - The object name.
+     * @param ids - Array of record IDs.
+     */
+    bulkDelete: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Update multiple records matching a query.
+     * Direct database push-down. DOES NOT trigger per-record hooks.
+     *
+     * @param object - The object name.
+     * @param query - The filtering criteria.
+     * @param data - The data to update.
+     * @returns Count of modified records.
+     */
+    updateMany: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNumber>>>;
+    /**
+     * Delete multiple records matching a query.
+     * Direct database push-down. DOES NOT trigger per-record hooks.
+     *
+     * @param object - The object name.
+     * @param query - The filtering criteria.
+     * @returns Count of deleted records.
+     */
+    deleteMany: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNumber>>>;
+    /**
+     * Begin a new database transaction.
+     * @param options - Isolation level and other settings.
+     * @returns A transaction handle to be passed to subsequent operations via `options.transaction`.
+     */
+    beginTransaction: z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodObject<{
+        isolationLevel: z.ZodOptional<z.ZodEnum<["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]>>;
+    }, "strip", z.ZodTypeAny, {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE" | "SNAPSHOT" | undefined;
+    }, {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE" | "SNAPSHOT" | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    /**
+     * Commit the transaction.
+     * @param transaction - The transaction handle.
+     */
+    commit: z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Rollback the transaction.
+     * @param transaction - The transaction handle.
+     */
+    rollback: z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Synchronize the database schema with the Object definition.
+     * This is an idempotent operation: it should create tables if missing,
+     * add columns if missing, and update indexes.
+     *
+     * @param object - The object name.
+     * @param schema - The full Object Schema (fields, indexes, etc).
+     * @param options - Driver options.
+     */
+    syncSchema: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Drop the underlying table or collection for an object.
+     * WARNING: Destructive operation.
+     *
+     * @param object - The object name.
+     */
+    dropTable: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Analyze query performance.
+     * Returns execution plan without executing the query (where possible).
+     *
+     * @param object - The object name.
+     * @param query - The query to explain.
+     * @returns The execution plan details.
+     */
+    explain: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("../data").FilterCondition, z.ZodTypeDef, import("../data").FilterCondition>>;
+        windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+            field: z.ZodOptional<z.ZodString>;
+            alias: z.ZodString;
+            over: z.ZodObject<{
+                partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    field: string;
+                    order: "asc" | "desc";
+                }, {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }>, "many">>;
+                frame: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                    start: z.ZodOptional<z.ZodString>;
+                    end: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }, {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Transaction handle/identifier.
+         * If provided, the operation must run within this transaction.
+         */
+        transaction: z.ZodOptional<z.ZodAny>;
+        /**
+         * Operation timeout in milliseconds.
+         */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether to bypass cache and force a fresh read.
+         */
+        skipCache: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Distributed Tracing Context.
+         * Used for passing OpenTelemetry span context or request IDs for observability.
+         */
+        traceContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Tenant Identifier.
+         * For multi-tenant databases (row-level security or schema-per-tenant).
+         */
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }, {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>>;
+}, "strip", z.ZodTypeAny, {
+    find: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    count: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    } | undefined, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    name: string;
+    update: (args_0: string, args_1: string | number, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    delete: (args_0: string, args_1: string | number, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<boolean>;
+    create: (args_0: string, args_1: Record<string, any>, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    upsert: (args_0: string, args_1: Record<string, any>, args_2: string[] | undefined, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    version: string;
+    supports: {
+        joins: boolean;
+        transactions: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch: boolean;
+        geoSpatial: boolean;
+    };
+    connect: (...args: unknown[]) => Promise<void>;
+    disconnect: (...args: unknown[]) => Promise<void>;
+    checkHealth: (...args: unknown[]) => Promise<boolean>;
+    execute: (args_0: any, args_1: any[] | undefined, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    findStream: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => any;
+    findOne: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any> | null>;
+    bulkCreate: (args_0: string, args_1: Record<string, any>[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkUpdate: (args_0: string, args_1: {
+        id: string | number;
+        data: Record<string, any>;
+    }[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkDelete: (args_0: string, args_1: (string | number)[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    beginTransaction: (args_0: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE" | "SNAPSHOT" | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    commit: (args_0: any, ...args: unknown[]) => Promise<void>;
+    rollback: (args_0: any, ...args: unknown[]) => Promise<void>;
+    syncSchema: (args_0: string, args_1: any, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    dropTable: (args_0: string, args_1: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    getPoolStats?: ((...args: unknown[]) => {
+        active: number;
+        total: number;
+        idle: number;
+        waiting: number;
+    } | undefined) | undefined;
+    updateMany?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>) | undefined;
+    deleteMany?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>) | undefined;
+    explain?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>) | undefined;
+}, {
+    find: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    count: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    } | undefined, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    name: string;
+    update: (args_0: string, args_1: string | number, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    delete: (args_0: string, args_1: string | number, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<boolean>;
+    create: (args_0: string, args_1: Record<string, any>, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    upsert: (args_0: string, args_1: Record<string, any>, args_2: string[] | undefined, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    version: string;
+    supports: {
+        joins: boolean;
+        transactions: boolean;
+        queryFilters: boolean;
+        queryAggregations: boolean;
+        querySorting: boolean;
+        queryPagination: boolean;
+        queryWindowFunctions: boolean;
+        querySubqueries: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+        vectorSearch?: boolean | undefined;
+        geoSpatial?: boolean | undefined;
+    };
+    connect: (...args: unknown[]) => Promise<void>;
+    disconnect: (...args: unknown[]) => Promise<void>;
+    checkHealth: (...args: unknown[]) => Promise<boolean>;
+    execute: (args_0: any, args_1: any[] | undefined, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    findStream: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => any;
+    findOne: (args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any> | null>;
+    bulkCreate: (args_0: string, args_1: Record<string, any>[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkUpdate: (args_0: string, args_1: {
+        id: string | number;
+        data: Record<string, any>;
+    }[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkDelete: (args_0: string, args_1: (string | number)[], args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    beginTransaction: (args_0: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE" | "SNAPSHOT" | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    commit: (args_0: any, ...args: unknown[]) => Promise<void>;
+    rollback: (args_0: any, ...args: unknown[]) => Promise<void>;
+    syncSchema: (args_0: string, args_1: any, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    dropTable: (args_0: string, args_1: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    getPoolStats?: ((...args: unknown[]) => {
+        active: number;
+        total: number;
+        idle: number;
+        waiting: number;
+    } | undefined) | undefined;
+    updateMany?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>) | undefined;
+    deleteMany?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>) | undefined;
+    explain?: ((args_0: string, args_1: {
+        object: string;
+        where?: import("../data").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
+        aggregations?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            filter?: import("../data").FilterCondition | undefined;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("../data").FilterCondition | undefined;
+        windowFunctions?: {
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                partitionBy?: string[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        tenantId?: string | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+        traceContext?: Record<string, string> | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>) | undefined;
+}>;
+/**
+ * TypeScript types
+ */
+export type DriverOptions = z.infer<typeof DriverOptionsSchema>;
+export type DriverCapabilities = z.infer<typeof DriverCapabilitiesSchema>;
+export type DriverInterface = z.infer<typeof DriverInterfaceSchema>;
+//# sourceMappingURL=driver.zod.d.ts.map