@objectstack/spec 0.1.1 → 0.1.2

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

@@ -0,0 +1,1525 @@
+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>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number | undefined;
+    transaction?: any;
+    skipCache?: boolean | undefined;
+}, {
+    timeout?: number | undefined;
+    transaction?: any;
+    skipCache?: boolean | 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 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;
+}, "strip", z.ZodTypeAny, {
+    joins: boolean;
+    transactions: boolean;
+    fullTextSearch: boolean;
+    jsonFields: boolean;
+    arrayFields: boolean;
+}, {
+    joins: boolean;
+    transactions: boolean;
+    fullTextSearch: boolean;
+    jsonFields: boolean;
+    arrayFields: boolean;
+}>;
+/**
+ * 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 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;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+    }, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+    }>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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
+     * });
+     */
+    find: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: 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>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        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, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        sort: 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">>;
+        top: z.ZodOptional<z.ZodNumber>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    /**
+     * 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.
+     */
+    findOne: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        object: z.ZodString;
+        fields: 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>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        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, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        sort: 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">>;
+        top: z.ZodOptional<z.ZodNumber>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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.).
+     */
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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.
+     */
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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">>;
+        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>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }>, "many">>;
+        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, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }, {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }, {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }>, "many">>;
+        filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+        sort: 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">>;
+        top: z.ZodOptional<z.ZodNumber>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    /**
+     * Begin a new database transaction.
+     * @returns A transaction handle to be passed to subsequent operations via `options.transaction`.
+     */
+    beginTransaction: z.ZodFunction<z.ZodTuple<[], 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }, {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+}, "strip", z.ZodTypeAny, {
+    find: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    name: string;
+    count: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    } | undefined, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    create: (args_0: string, args_1: Record<string, any>, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    update: (args_0: string, args_1: string | number, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    delete: (args_0: string, args_1: string | number, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<boolean>;
+    bulkCreate: (args_0: string, args_1: Record<string, any>[], args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkDelete: (args_0: string, args_1: (string | number)[], args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    execute: (args_0: any, args_1: any[] | undefined, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    version: string;
+    supports: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+    };
+    connect: (...args: unknown[]) => Promise<void>;
+    disconnect: (...args: unknown[]) => Promise<void>;
+    checkHealth: (...args: unknown[]) => Promise<boolean>;
+    findOne: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order?: "asc" | "desc" | undefined;
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any> | null>;
+    beginTransaction: (...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;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    dropTable: (args_0: string, args_1: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+}, {
+    find: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    name: string;
+    count: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    } | undefined, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    create: (args_0: string, args_1: Record<string, any>, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    update: (args_0: string, args_1: string | number, args_2: Record<string, any>, args_3: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>>;
+    delete: (args_0: string, args_1: string | number, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<boolean>;
+    bulkCreate: (args_0: string, args_1: Record<string, any>[], args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | 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;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
+    bulkDelete: (args_0: string, args_1: (string | number)[], args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    execute: (args_0: any, args_1: any[] | undefined, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    version: string;
+    supports: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+    };
+    connect: (...args: unknown[]) => Promise<void>;
+    disconnect: (...args: unknown[]) => Promise<void>;
+    checkHealth: (...args: unknown[]) => Promise<boolean>;
+    findOne: (args_0: string, args_1: {
+        object: string;
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        fields?: any[] | undefined;
+        distinct?: boolean | undefined;
+        aggregations?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            alias: string;
+            field?: string | undefined;
+            distinct?: boolean | undefined;
+        }[] | undefined;
+        windowFunctions?: {
+            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            alias: string;
+            over: {
+                partitionBy?: string[] | undefined;
+                orderBy?: {
+                    field: string;
+                    order: "asc" | "desc";
+                }[] | undefined;
+                frame?: {
+                    type?: "rows" | "range" | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                } | undefined;
+            };
+            field?: string | undefined;
+        }[] | undefined;
+        filters?: any;
+        joins?: any[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: any;
+        top?: number | undefined;
+        skip?: number | undefined;
+    }, args_2: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<Record<string, any> | null>;
+    beginTransaction: (...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;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+    dropTable: (args_0: string, args_1: {
+        timeout?: number | undefined;
+        transaction?: any;
+        skipCache?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<void>;
+}>;
+/**
+ * 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