@objectstack/spec 0.9.1 → 1.0.0

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

@@ -13,7 +13,7 @@ import { z } from 'zod';
  * Data Engine Query filter conditions
  * Supports simple key-value map or complex Logic/Field expressions (DSL)
  */
-export declare const DataEngineFilterSchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>;
+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:
@@ -21,136 +21,487 @@ export declare const DataEngineFilterSchema: z.ZodUnion<readonly [z.ZodRecord<z.
  * - { name: 1 }
  * - [{ field: 'name', order: 'asc' }]
  */
-export declare const DataEngineSortSchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-    asc: "asc";
-    desc: "desc";
-}>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+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: "asc";
-        desc: "desc";
-    }>>;
-}, z.core.$strip>>]>;
+    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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-        asc: "asc";
-        desc: "desc";
-    }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-            desc: "desc";
-        }>>;
-    }, z.core.$strip>>]>>;
+        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>;
-    populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+    /**
+     * 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>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    returning?: boolean | undefined;
+}, {
+    returning?: boolean | undefined;
+}>;
 export declare const DataEngineUpdateOptionsSchema: z.ZodObject<{
-    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+    /** 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>>;
-}, z.core.$strip>;
+}, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+    /** 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>>;
-}, z.core.$strip>;
+}, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /** 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: "count";
-            sum: "sum";
-            avg: "avg";
-            min: "min";
-            max: "max";
-            count_distinct: "count_distinct";
-        }>;
+        method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
         alias: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-}, z.core.$strip>;
+    /** 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodArray<z.ZodAny>>>;
+        /**
+         * 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
-    insert: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>, z.ZodOptional<z.ZodObject<{
+        /**
+         * 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>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodNumber>>;
+        /** 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /** 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: "count";
-                sum: "sum";
-                avg: "avg";
-                min: "min";
-                max: "max";
-                count_distinct: "count_distinct";
-            }>;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
             alias: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>], null>, z.ZodPromise<z.ZodArray<z.ZodAny>>>;
-}, z.core.$strip>;
+        }, "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)
  *
@@ -164,111 +515,412 @@ export declare const DataEngineFindRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"find">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        /**
+         * 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        /**
+         * 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<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
+    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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        /** 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /** 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: "count";
-                sum: "sum";
-                avg: "avg";
-                min: "min";
-                max: "max";
-                count_distinct: "count_distinct";
-            }>;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
             alias: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+        }, "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>>;
-}, z.core.$strip>;
+}, "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.
@@ -276,345 +928,1702 @@ export declare const DataEngineExecuteRequestSchema: z.ZodObject<{
 export declare const DataEngineVectorFindRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"vectorFind">;
     object: z.ZodString;
-    vector: z.ZodArray<z.ZodNumber>;
-    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    select: z.ZodOptional<z.ZodArray<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>;
-}, z.core.$strip>;
+}, "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<[z.ZodObject<{
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
         method: z.ZodLiteral<"find">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-                asc: "asc";
-                desc: "desc";
-            }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                    desc: "desc";
-                }>>;
-            }, z.core.$strip>>]>>;
+                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>;
-            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+            /**
+             * 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-                asc: "asc";
-                desc: "desc";
-            }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                    desc: "desc";
-                }>>;
-            }, z.core.$strip>>]>>;
+                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>;
-            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+            /**
+             * 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<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
+        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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+            /** 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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+            /** 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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            /** 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: "count";
-                    sum: "sum";
-                    avg: "avg";
-                    min: "min";
-                    max: "max";
-                    count_distinct: "count_distinct";
-                }>;
+                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
                 alias: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
+            }, "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>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "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;
-        vector: z.ZodArray<z.ZodNumber>;
-        filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<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>;
-    }, z.core.$strip>], "method">>;
+    }, "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>>;
-}, z.core.$strip>;
+}, "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<[z.ZodObject<{
+export declare const DataEngineRequestSchema: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
     method: z.ZodLiteral<"find">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
+        /**
+         * 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                desc: "desc";
-            }>>;
-        }, z.core.$strip>>]>>;
+            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>;
-        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
+        /**
+         * 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<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
+    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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+        /** 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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
+    }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /** 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: "count";
-                sum: "sum";
-                avg: "avg";
-                min: "min";
-                max: "max";
-                count_distinct: "count_distinct";
-            }>;
+            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
             alias: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
+        }, "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<[z.ZodObject<{
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
         method: z.ZodLiteral<"find">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-                asc: "asc";
-                desc: "desc";
-            }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                    desc: "desc";
-                }>>;
-            }, z.core.$strip>>]>>;
+                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>;
-            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+            /**
+             * 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodEnum<{
-                asc: "asc";
-                desc: "desc";
-            }>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<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: "asc";
-                    desc: "desc";
-                }>>;
-            }, z.core.$strip>>]>>;
+                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>;
-            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+            /**
+             * 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<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
+        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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+            /** 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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
+            /** 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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, "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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, 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: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            /** 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: "count";
-                    sum: "sum";
-                    avg: "avg";
-                    min: "min";
-                    max: "max";
-                    count_distinct: "count_distinct";
-                }>;
+                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
                 alias: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
+            }, "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>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "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;
-        vector: z.ZodArray<z.ZodNumber>;
-        filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-        select: z.ZodOptional<z.ZodArray<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>;
-    }, z.core.$strip>], "method">>;
+    }, "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>>;
-}, z.core.$strip>, z.ZodObject<{
+}, "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>>;
-}, z.core.$strip>, z.ZodObject<{
+}, "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;
-    vector: z.ZodArray<z.ZodNumber>;
-    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, unknown, z.core.$ZodTypeInternals<import("./filter.zod").FilterCondition, unknown>>]>>;
-    select: z.ZodOptional<z.ZodArray<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>;
-}, z.core.$strip>], "method">;
+}, "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>;