@objectstack/spec 0.6.1 → 0.7.1

package/dist/data/data-engine.zod.d.ts

@@ -0,0 +1,2636 @@
+import { z } from 'zod';
+/**
+ * Data Engine Protocol
+ *
+ * Defines the standard interface for data persistence engines in ObjectStack.
+ * This protocol abstracts the underlying storage mechanism (SQL, NoSQL, API, Memory),
+ * allowing the ObjectQL engine to execute standardized CRUD and Aggregation operations
+ * regardless of where the data resides.
+ *
+ * The Data Engine acts as the "Driver" layer in the Hexagonal Architecture.
+ */
+/**
+ * Data Engine Query filter conditions
+ * Supports simple key-value map or complex Logic/Field expressions (DSL)
+ */
+export declare const DataEngineFilterSchema: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>;
+/**
+ * Sort order definition
+ * Supports:
+ * - { name: 'asc' }
+ * - { name: 1 }
+ * - [{ field: 'name', order: 'asc' }]
+ */
+export declare const DataEngineSortSchema: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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">]>;
+export declare const DataEngineQueryOptionsSchema: z.ZodObject<{
+    /** Filter conditions (WHERE) */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /** Fields to select (SELECT) */
+    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Sort order (ORDER BY) */
+    sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+    limit: z.ZodOptional<z.ZodNumber>;
+    /** Skip number of results (OFFSET) */
+    skip: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Maximum number of results (OData style)
+     * Takes precedence over limit if both specified
+     */
+    top: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Include related records (JOIN/Populate)
+     * List of relationship field names to expand
+     */
+    populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    skip?: number | undefined;
+    top?: number | undefined;
+    populate?: string[] | undefined;
+}, {
+    sort?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    skip?: number | undefined;
+    top?: number | undefined;
+    populate?: string[] | undefined;
+}>;
+export declare const DataEngineInsertOptionsSchema: z.ZodObject<{
+    /**
+     * Return the inserted record(s)?
+     * Some drivers support RETURNING clause for efficiency.
+     * Default: true
+     */
+    returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    returning?: boolean | undefined;
+}, {
+    returning?: boolean | undefined;
+}>;
+export declare const DataEngineUpdateOptionsSchema: z.ZodObject<{
+    /** Filter conditions to identify records to update */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /**
+     * Perform an upsert?
+     * If true, insert if not found.
+     */
+    upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    /**
+     * Update multiple records?
+     * If false, only the first match is updated.
+     * Default: false
+     */
+    multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    /**
+     * Return the updated record(s)?
+     * Default: false (returns update count/status)
+     */
+    returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    upsert?: boolean | undefined;
+    returning?: boolean | undefined;
+    multi?: boolean | undefined;
+}, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    upsert?: boolean | undefined;
+    returning?: boolean | undefined;
+    multi?: boolean | undefined;
+}>;
+export declare const DataEngineDeleteOptionsSchema: z.ZodObject<{
+    /** Filter conditions to identify records to delete */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /**
+     * Delete multiple records?
+     * If false, only the first match is deleted.
+     * Default: false
+     */
+    multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    multi?: boolean | undefined;
+}, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    multi?: boolean | undefined;
+}>;
+export declare const DataEngineAggregateOptionsSchema: z.ZodObject<{
+    /** Filter conditions (WHERE) */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /** Group By fields */
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Aggregation definitions
+     * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+     */
+    aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+        alias?: string | undefined;
+    }, {
+        field: string;
+        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+        alias?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    aggregations?: {
+        field: string;
+        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+        alias?: string | undefined;
+    }[] | undefined;
+    groupBy?: string[] | undefined;
+}, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    aggregations?: {
+        field: string;
+        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+        alias?: string | undefined;
+    }[] | undefined;
+    groupBy?: string[] | undefined;
+}>;
+export declare const DataEngineCountOptionsSchema: z.ZodObject<{
+    /** Filter conditions */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+}, "strip", z.ZodTypeAny, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+}, {
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+}>;
+export declare const DataEngineContractSchema: z.ZodObject<{
+    find: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodAny, "many">>>;
+    findOne: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    insert: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>, z.ZodOptional<z.ZodObject<{
+        /**
+         * Return the inserted record(s)?
+         * Some drivers support RETURNING clause for efficiency.
+         * Default: true
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        returning?: boolean | undefined;
+    }, {
+        returning?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    update: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to update */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Perform an upsert?
+         * If true, insert if not found.
+         */
+        upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Update multiple records?
+         * If false, only the first match is updated.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Return the updated record(s)?
+         * Default: false (returns update count/status)
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    delete: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to delete */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Delete multiple records?
+         * If false, only the first match is deleted.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    count: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
+        /** Filter conditions */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNumber>>;
+    aggregate: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Group By fields */
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Aggregation definitions
+         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+         */
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodAny, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    find: (args_0: string, args_1: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any[]>;
+    count: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    insert: (args_0: string, args_1: Record<string, any> | Record<string, any>[], args_2: {
+        returning?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    update: (args_0: string, args_1: Record<string, any>, args_2: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    delete: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    aggregate: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }, ...args: unknown[]) => Promise<any[]>;
+    findOne: (args_0: string, args_1: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+}, {
+    find: (args_0: string, args_1: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any[]>;
+    count: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined, ...args: unknown[]) => Promise<number>;
+    insert: (args_0: string, args_1: Record<string, any> | Record<string, any>[], args_2: {
+        returning?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    update: (args_0: string, args_1: Record<string, any>, args_2: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    delete: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+    aggregate: (args_0: string, args_1: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }, ...args: unknown[]) => Promise<any[]>;
+    findOne: (args_0: string, args_1: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined, ...args: unknown[]) => Promise<any>;
+}>;
+/**
+ * Data Engine RPC Request (Virtual ObjectQL)
+ *
+ * This schema defines the serialized format for executing Data Engine operations
+ * via HTTP, Message Queue, or Plugin boundaries.
+ *
+ * It enables "Virtual Data Engines" where the implementation resides in a
+ * separate microservice or plugin.
+ */
+export declare const DataEngineFindRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"find">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "find";
+    query?: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "find";
+    query?: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const DataEngineFindOneRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"findOne">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "findOne";
+    query?: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "findOne";
+    query?: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const DataEngineInsertRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"insert">;
+    object: z.ZodString;
+    data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+    options: z.ZodOptional<z.ZodObject<{
+        /**
+         * Return the inserted record(s)?
+         * Some drivers support RETURNING clause for efficiency.
+         * Default: true
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        returning?: boolean | undefined;
+    }, {
+        returning?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "insert";
+    data: Record<string, any> | Record<string, any>[];
+    options?: {
+        returning?: boolean | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "insert";
+    data: Record<string, any> | Record<string, any>[];
+    options?: {
+        returning?: boolean | undefined;
+    } | undefined;
+}>;
+export declare const DataEngineUpdateRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"update">;
+    object: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    id: z.ZodOptional<z.ZodAny>;
+    options: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to update */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Perform an upsert?
+         * If true, insert if not found.
+         */
+        upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Update multiple records?
+         * If false, only the first match is updated.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Return the updated record(s)?
+         * Default: false (returns update count/status)
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "update";
+    data: Record<string, any>;
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}, {
+    object: string;
+    method: "update";
+    data: Record<string, any>;
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}>;
+export declare const DataEngineDeleteRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"delete">;
+    object: z.ZodString;
+    id: z.ZodOptional<z.ZodAny>;
+    options: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to delete */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Delete multiple records?
+         * If false, only the first match is deleted.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "delete";
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}, {
+    object: string;
+    method: "delete";
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}>;
+export declare const DataEngineCountRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"count">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "count";
+    query?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "count";
+    query?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined;
+}>;
+export declare const DataEngineAggregateRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"aggregate">;
+    object: z.ZodString;
+    query: z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Group By fields */
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Aggregation definitions
+         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+         */
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    query: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    };
+    method: "aggregate";
+}, {
+    object: string;
+    query: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    };
+    method: "aggregate";
+}>;
+/**
+ * Data Engine Execute Request (Raw Command)
+ * Execute a raw command/query native to the driver (e.g. SQL, Shell, Remote API).
+ */
+export declare const DataEngineExecuteRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"execute">;
+    /** The abstract command (string SQL, or JSON object) */
+    command: z.ZodAny;
+    /** Optional options */
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    method: "execute";
+    options?: Record<string, any> | undefined;
+    command?: any;
+}, {
+    method: "execute";
+    options?: Record<string, any> | undefined;
+    command?: any;
+}>;
+/**
+ * Data Engine Vector Find Request (AI/RAG)
+ * Perform a similarity search using vector embeddings.
+ */
+export declare const DataEngineVectorFindRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"vectorFind">;
+    object: z.ZodString;
+    /** The vector embedding to search for */
+    vector: z.ZodArray<z.ZodNumber, "many">;
+    /** Optional pre-filter (Metadata filtering) */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /** Fields to select */
+    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Number of results */
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    /** Minimum similarity score (0-1) or distance threshold */
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    vector: number[];
+    method: "vectorFind";
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    threshold?: number | undefined;
+}, {
+    object: string;
+    vector: number[];
+    method: "vectorFind";
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    threshold?: number | undefined;
+}>;
+/**
+ * Data Engine Batch Request
+ * Execute multiple operations in a single transaction/request efficiently.
+ */
+export declare const DataEngineBatchRequestSchema: z.ZodObject<{
+    method: z.ZodLiteral<"batch">;
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+        method: z.ZodLiteral<"find">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Fields to select (SELECT) */
+            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Sort order (ORDER BY) */
+            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+            limit: z.ZodOptional<z.ZodNumber>;
+            /** Skip number of results (OFFSET) */
+            skip: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum number of results (OData style)
+             * Takes precedence over limit if both specified
+             */
+            top: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Include related records (JOIN/Populate)
+             * List of relationship field names to expand
+             */
+            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }, {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"findOne">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Fields to select (SELECT) */
+            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Sort order (ORDER BY) */
+            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+            limit: z.ZodOptional<z.ZodNumber>;
+            /** Skip number of results (OFFSET) */
+            skip: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum number of results (OData style)
+             * Takes precedence over limit if both specified
+             */
+            top: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Include related records (JOIN/Populate)
+             * List of relationship field names to expand
+             */
+            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }, {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"insert">;
+        object: z.ZodString;
+        data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+        options: z.ZodOptional<z.ZodObject<{
+            /**
+             * Return the inserted record(s)?
+             * Some drivers support RETURNING clause for efficiency.
+             * Default: true
+             */
+            returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            returning?: boolean | undefined;
+        }, {
+            returning?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"update">;
+        object: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodAny>;
+        id: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions to identify records to update */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /**
+             * Perform an upsert?
+             * If true, insert if not found.
+             */
+            upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            /**
+             * Update multiple records?
+             * If false, only the first match is updated.
+             * Default: false
+             */
+            multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            /**
+             * Return the updated record(s)?
+             * Default: false (returns update count/status)
+             */
+            returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }, {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"delete">;
+        object: z.ZodString;
+        id: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions to identify records to delete */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /**
+             * Delete multiple records?
+             * If false, only the first match is deleted.
+             * Default: false
+             */
+            multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }, {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"count">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"aggregate">;
+        object: z.ZodString;
+        query: z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Group By fields */
+            groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Aggregation definitions
+             * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+             */
+            aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+                alias: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }, {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    }, {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"execute">;
+        /** The abstract command (string SQL, or JSON object) */
+        command: z.ZodAny;
+        /** Optional options */
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    }, {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"vectorFind">;
+        object: z.ZodString;
+        /** The vector embedding to search for */
+        vector: z.ZodArray<z.ZodNumber, "many">;
+        /** Optional pre-filter (Metadata filtering) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Number of results */
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        /** Minimum similarity score (0-1) or distance threshold */
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    }, {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    }>]>, "many">;
+    /**
+     * Transaction Mode
+     * - true: All or nothing (Atomic)
+     * - false: Best effort, continue on error
+     */
+    transaction: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    method: "batch";
+    requests: ({
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    } | {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    } | {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    })[];
+    transaction?: boolean | undefined;
+}, {
+    method: "batch";
+    requests: ({
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    } | {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    } | {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    })[];
+    transaction?: boolean | undefined;
+}>;
+/**
+ * Unified Data Engine Request Union
+ * Use this to validate any incoming "Virtual ObjectQL" request.
+ */
+export declare const DataEngineRequestSchema: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+    method: z.ZodLiteral<"find">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "find";
+    query?: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "find";
+    query?: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"findOne">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select (SELECT) */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Sort order (ORDER BY) */
+        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+        limit: z.ZodOptional<z.ZodNumber>;
+        /** Skip number of results (OFFSET) */
+        skip: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Maximum number of results (OData style)
+         * Takes precedence over limit if both specified
+         */
+        top: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Include related records (JOIN/Populate)
+         * List of relationship field names to expand
+         */
+        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }, {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "findOne";
+    query?: {
+        sort?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "findOne";
+    query?: {
+        sort?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        skip?: number | undefined;
+        top?: number | undefined;
+        populate?: string[] | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"insert">;
+    object: z.ZodString;
+    data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+    options: z.ZodOptional<z.ZodObject<{
+        /**
+         * Return the inserted record(s)?
+         * Some drivers support RETURNING clause for efficiency.
+         * Default: true
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        returning?: boolean | undefined;
+    }, {
+        returning?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "insert";
+    data: Record<string, any> | Record<string, any>[];
+    options?: {
+        returning?: boolean | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "insert";
+    data: Record<string, any> | Record<string, any>[];
+    options?: {
+        returning?: boolean | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"update">;
+    object: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    id: z.ZodOptional<z.ZodAny>;
+    options: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to update */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Perform an upsert?
+         * If true, insert if not found.
+         */
+        upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Update multiple records?
+         * If false, only the first match is updated.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        /**
+         * Return the updated record(s)?
+         * Default: false (returns update count/status)
+         */
+        returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "update";
+    data: Record<string, any>;
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}, {
+    object: string;
+    method: "update";
+    data: Record<string, any>;
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        upsert?: boolean | undefined;
+        returning?: boolean | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"delete">;
+    object: z.ZodString;
+    id: z.ZodOptional<z.ZodAny>;
+    options: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions to identify records to delete */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /**
+         * Delete multiple records?
+         * If false, only the first match is deleted.
+         * Default: false
+         */
+        multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "delete";
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}, {
+    object: string;
+    method: "delete";
+    options?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        multi?: boolean | undefined;
+    } | undefined;
+    id?: any;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"count">;
+    object: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        /** Filter conditions */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    method: "count";
+    query?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined;
+}, {
+    object: string;
+    method: "count";
+    query?: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"aggregate">;
+    object: z.ZodString;
+    query: z.ZodObject<{
+        /** Filter conditions (WHERE) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Group By fields */
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Aggregation definitions
+         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+         */
+        aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }, {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }, {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    query: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    };
+    method: "aggregate";
+}, {
+    object: string;
+    query: {
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        aggregations?: {
+            field: string;
+            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+            alias?: string | undefined;
+        }[] | undefined;
+        groupBy?: string[] | undefined;
+    };
+    method: "aggregate";
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"batch">;
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+        method: z.ZodLiteral<"find">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Fields to select (SELECT) */
+            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Sort order (ORDER BY) */
+            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+            limit: z.ZodOptional<z.ZodNumber>;
+            /** Skip number of results (OFFSET) */
+            skip: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum number of results (OData style)
+             * Takes precedence over limit if both specified
+             */
+            top: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Include related records (JOIN/Populate)
+             * List of relationship field names to expand
+             */
+            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }, {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"findOne">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Fields to select (SELECT) */
+            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Sort order (ORDER BY) */
+            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, 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 number of results (LIMIT) */
+            limit: z.ZodOptional<z.ZodNumber>;
+            /** Skip number of results (OFFSET) */
+            skip: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Maximum number of results (OData style)
+             * Takes precedence over limit if both specified
+             */
+            top: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Include related records (JOIN/Populate)
+             * List of relationship field names to expand
+             */
+            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }, {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"insert">;
+        object: z.ZodString;
+        data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+        options: z.ZodOptional<z.ZodObject<{
+            /**
+             * Return the inserted record(s)?
+             * Some drivers support RETURNING clause for efficiency.
+             * Default: true
+             */
+            returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            returning?: boolean | undefined;
+        }, {
+            returning?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"update">;
+        object: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodAny>;
+        id: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions to identify records to update */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /**
+             * Perform an upsert?
+             * If true, insert if not found.
+             */
+            upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            /**
+             * Update multiple records?
+             * If false, only the first match is updated.
+             * Default: false
+             */
+            multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            /**
+             * Return the updated record(s)?
+             * Default: false (returns update count/status)
+             */
+            returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }, {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"delete">;
+        object: z.ZodString;
+        id: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions to identify records to delete */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /**
+             * Delete multiple records?
+             * If false, only the first match is deleted.
+             * Default: false
+             */
+            multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }, {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"count">;
+        object: z.ZodString;
+        query: z.ZodOptional<z.ZodObject<{
+            /** Filter conditions */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    }, {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"aggregate">;
+        object: z.ZodString;
+        query: z.ZodObject<{
+            /** Filter conditions (WHERE) */
+            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+            /** Group By fields */
+            groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Aggregation definitions
+             * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
+             */
+            aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+                alias: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }, {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        }, {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    }, {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"execute">;
+        /** The abstract command (string SQL, or JSON object) */
+        command: z.ZodAny;
+        /** Optional options */
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    }, {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    }>, z.ZodObject<{
+        method: z.ZodLiteral<"vectorFind">;
+        object: z.ZodString;
+        /** The vector embedding to search for */
+        vector: z.ZodArray<z.ZodNumber, "many">;
+        /** Optional pre-filter (Metadata filtering) */
+        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+        /** Fields to select */
+        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Number of results */
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        /** Minimum similarity score (0-1) or distance threshold */
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    }, {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    }>]>, "many">;
+    /**
+     * Transaction Mode
+     * - true: All or nothing (Atomic)
+     * - false: Best effort, continue on error
+     */
+    transaction: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    method: "batch";
+    requests: ({
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    } | {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    } | {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    })[];
+    transaction?: boolean | undefined;
+}, {
+    method: "batch";
+    requests: ({
+        object: string;
+        method: "find";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "findOne";
+        query?: {
+            sort?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            limit?: number | undefined;
+            select?: string[] | undefined;
+            skip?: number | undefined;
+            top?: number | undefined;
+            populate?: string[] | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "insert";
+        data: Record<string, any> | Record<string, any>[];
+        options?: {
+            returning?: boolean | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        method: "update";
+        data: Record<string, any>;
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            upsert?: boolean | undefined;
+            returning?: boolean | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "delete";
+        options?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            multi?: boolean | undefined;
+        } | undefined;
+        id?: any;
+    } | {
+        object: string;
+        method: "count";
+        query?: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        } | undefined;
+    } | {
+        object: string;
+        query: {
+            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+            aggregations?: {
+                field: string;
+                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                alias?: string | undefined;
+            }[] | undefined;
+            groupBy?: string[] | undefined;
+        };
+        method: "aggregate";
+    } | {
+        method: "execute";
+        options?: Record<string, any> | undefined;
+        command?: any;
+    } | {
+        object: string;
+        vector: number[];
+        method: "vectorFind";
+        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+        limit?: number | undefined;
+        select?: string[] | undefined;
+        threshold?: number | undefined;
+    })[];
+    transaction?: boolean | undefined;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"execute">;
+    /** The abstract command (string SQL, or JSON object) */
+    command: z.ZodAny;
+    /** Optional options */
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    method: "execute";
+    options?: Record<string, any> | undefined;
+    command?: any;
+}, {
+    method: "execute";
+    options?: Record<string, any> | undefined;
+    command?: any;
+}>, z.ZodObject<{
+    method: z.ZodLiteral<"vectorFind">;
+    object: z.ZodString;
+    /** The vector embedding to search for */
+    vector: z.ZodArray<z.ZodNumber, "many">;
+    /** Optional pre-filter (Metadata filtering) */
+    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
+    /** Fields to select */
+    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Number of results */
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    /** Minimum similarity score (0-1) or distance threshold */
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    vector: number[];
+    method: "vectorFind";
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    threshold?: number | undefined;
+}, {
+    object: string;
+    vector: number[];
+    method: "vectorFind";
+    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
+    limit?: number | undefined;
+    select?: string[] | undefined;
+    threshold?: number | undefined;
+}>]>;
+export type DataEngineFilter = z.infer<typeof DataEngineFilterSchema>;
+export type DataEngineSort = z.infer<typeof DataEngineSortSchema>;
+export type DataEngineQueryOptions = z.infer<typeof DataEngineQueryOptionsSchema>;
+export type DataEngineInsertOptions = z.infer<typeof DataEngineInsertOptionsSchema>;
+export type DataEngineUpdateOptions = z.infer<typeof DataEngineUpdateOptionsSchema>;
+export type DataEngineDeleteOptions = z.infer<typeof DataEngineDeleteOptionsSchema>;
+export type DataEngineAggregateOptions = z.infer<typeof DataEngineAggregateOptionsSchema>;
+export type DataEngineCountOptions = z.infer<typeof DataEngineCountOptionsSchema>;
+export type DataEngineRequest = z.infer<typeof DataEngineRequestSchema>;
+//# sourceMappingURL=data-engine.zod.d.ts.map