@objectstack/spec 0.7.2 → 0.8.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<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>;
+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>>]>;
 /**
  * Sort order definition
  * Supports:
@@ -21,487 +21,136 @@ export declare const DataEngineFilterSchema: z.ZodUnion<[z.ZodRecord<z.ZodString
  * - { name: 1 }
  * - [{ field: 'name', order: 'asc' }]
  */
-export declare const DataEngineSortSchema: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+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<{
     field: z.ZodString;
-    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-}, "strip", z.ZodTypeAny, {
-    field: string;
-    order: "asc" | "desc";
-}, {
-    field: string;
-    order?: "asc" | "desc" | undefined;
-}>, "many">]>;
+    order: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>>]>;
 export declare const DataEngineQueryOptionsSchema: z.ZodObject<{
-    /** Filter conditions (WHERE) */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /** Fields to select (SELECT) */
-    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Sort order (ORDER BY) */
-    sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+    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<{
         field: z.ZodString;
-        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-    }, "strip", z.ZodTypeAny, {
-        field: string;
-        order: "asc" | "desc";
-    }, {
-        field: string;
-        order?: "asc" | "desc" | undefined;
-    }>, "many">]>>;
-    /** Limit number of results (LIMIT) */
+        order: z.ZodDefault<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strip>>]>>;
     limit: z.ZodOptional<z.ZodNumber>;
-    /** Skip number of results (OFFSET) */
     skip: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Maximum number of results (OData style)
-     * Takes precedence over limit if both specified
-     */
     top: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Include related records (JOIN/Populate)
-     * List of relationship field names to expand
-     */
-    populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    sort?: {
-        field: string;
-        order: "asc" | "desc";
-    }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    skip?: number | undefined;
-    top?: number | undefined;
-    populate?: string[] | undefined;
-}, {
-    sort?: {
-        field: string;
-        order?: "asc" | "desc" | undefined;
-    }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    skip?: number | undefined;
-    top?: number | undefined;
-    populate?: string[] | undefined;
-}>;
+    populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const DataEngineInsertOptionsSchema: z.ZodObject<{
-    /**
-     * Return the inserted record(s)?
-     * Some drivers support RETURNING clause for efficiency.
-     * Default: true
-     */
     returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    returning?: boolean | undefined;
-}, {
-    returning?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare const DataEngineUpdateOptionsSchema: z.ZodObject<{
-    /** Filter conditions to identify records to update */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /**
-     * Perform an upsert?
-     * If true, insert if not found.
-     */
+    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>>]>>;
     upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    /**
-     * Update multiple records?
-     * If false, only the first match is updated.
-     * Default: false
-     */
     multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    /**
-     * Return the updated record(s)?
-     * Default: false (returns update count/status)
-     */
     returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    upsert?: boolean | undefined;
-    returning?: boolean | undefined;
-    multi?: boolean | undefined;
-}, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    upsert?: boolean | undefined;
-    returning?: boolean | undefined;
-    multi?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare const DataEngineDeleteOptionsSchema: z.ZodObject<{
-    /** Filter conditions to identify records to delete */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /**
-     * Delete multiple records?
-     * If false, only the first match is deleted.
-     * Default: false
-     */
+    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>>]>>;
     multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    multi?: boolean | undefined;
-}, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    multi?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare const DataEngineAggregateOptionsSchema: z.ZodObject<{
-    /** Filter conditions (WHERE) */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /** Group By fields */
-    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /**
-     * Aggregation definitions
-     * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-     */
+    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>>;
     aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
-        method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+        method: z.ZodEnum<{
+            count: "count";
+            sum: "sum";
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count_distinct: "count_distinct";
+        }>;
         alias: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        field: string;
-        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-        alias?: string | undefined;
-    }, {
-        field: string;
-        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-        alias?: string | undefined;
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    aggregations?: {
-        field: string;
-        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-        alias?: string | undefined;
-    }[] | undefined;
-    groupBy?: string[] | undefined;
-}, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    aggregations?: {
-        field: string;
-        method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-        alias?: string | undefined;
-    }[] | undefined;
-    groupBy?: string[] | undefined;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export declare const DataEngineCountOptionsSchema: z.ZodObject<{
-    /** Filter conditions */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-}, "strip", z.ZodTypeAny, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-}, {
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-}>;
+    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>;
 export declare const DataEngineContractSchema: z.ZodObject<{
     find: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodAny, "many">>>;
+        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodArray<z.ZodAny>>>;
     findOne: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
-    insert: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>, z.ZodOptional<z.ZodObject<{
-        /**
-         * Return the inserted record(s)?
-         * Some drivers support RETURNING clause for efficiency.
-         * Default: true
-         */
+        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<{
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        returning?: boolean | undefined;
-    }, {
-        returning?: boolean | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
     update: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to update */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Perform an upsert?
-         * If true, insert if not found.
-         */
+        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>>]>>;
         upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Update multiple records?
-         * If false, only the first match is updated.
-         * Default: false
-         */
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Return the updated record(s)?
-         * Default: false (returns update count/status)
-         */
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
     delete: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to delete */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Delete multiple records?
-         * If false, only the first match is deleted.
-         * Default: false
-         */
+        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>>]>>;
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodAny>>;
     count: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodObject<{
-        /** Filter conditions */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }>>], z.ZodUnknown>, z.ZodPromise<z.ZodNumber>>;
+        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>>;
     aggregate: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Group By fields */
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Aggregation definitions
-         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-         */
+        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>>;
         aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            method: z.ZodEnum<{
+                count: "count";
+                sum: "sum";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count_distinct: "count_distinct";
+            }>;
             alias: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }>], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodAny, "many">>>;
-}, "strip", z.ZodTypeAny, {
-    find: (args_0: string, args_1: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any[]>;
-    count: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined, ...args: unknown[]) => Promise<number>;
-    insert: (args_0: string, args_1: Record<string, any> | Record<string, any>[], args_2: {
-        returning?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    update: (args_0: string, args_1: Record<string, any>, args_2: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    delete: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    aggregate: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }, ...args: unknown[]) => Promise<any[]>;
-    findOne: (args_0: string, args_1: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-}, {
-    find: (args_0: string, args_1: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any[]>;
-    count: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined, ...args: unknown[]) => Promise<number>;
-    insert: (args_0: string, args_1: Record<string, any> | Record<string, any>[], args_2: {
-        returning?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    update: (args_0: string, args_1: Record<string, any>, args_2: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    delete: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-    aggregate: (args_0: string, args_1: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }, ...args: unknown[]) => Promise<any[]>;
-    findOne: (args_0: string, args_1: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined, ...args: unknown[]) => Promise<any>;
-}>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>], null>, z.ZodPromise<z.ZodArray<z.ZodAny>>>;
+}, z.core.$strip>;
 /**
  * Data Engine RPC Request (Virtual ObjectQL)
  *
@@ -515,412 +164,111 @@ export declare const DataEngineFindRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"find">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "find";
-    query?: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "find";
-    query?: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}>;
+        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const DataEngineFindOneRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"findOne">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "findOne";
-    query?: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "findOne";
-    query?: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}>;
+        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const DataEngineInsertRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"insert">;
     object: z.ZodString;
-    data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+    data: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
     options: z.ZodOptional<z.ZodObject<{
-        /**
-         * Return the inserted record(s)?
-         * Some drivers support RETURNING clause for efficiency.
-         * Default: true
-         */
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        returning?: boolean | undefined;
-    }, {
-        returning?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "insert";
-    data: Record<string, any> | Record<string, any>[];
-    options?: {
-        returning?: boolean | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "insert";
-    data: Record<string, any> | Record<string, any>[];
-    options?: {
-        returning?: boolean | undefined;
-    } | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const DataEngineUpdateRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"update">;
     object: z.ZodString;
     data: z.ZodRecord<z.ZodString, z.ZodAny>;
     id: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to update */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Perform an upsert?
-         * If true, insert if not found.
-         */
+        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>>]>>;
         upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Update multiple records?
-         * If false, only the first match is updated.
-         * Default: false
-         */
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Return the updated record(s)?
-         * Default: false (returns update count/status)
-         */
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "update";
-    data: Record<string, any>;
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}, {
-    object: string;
-    method: "update";
-    data: Record<string, any>;
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const DataEngineDeleteRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"delete">;
     object: z.ZodString;
     id: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to delete */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Delete multiple records?
-         * If false, only the first match is deleted.
-         * Default: false
-         */
+        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>>]>>;
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "delete";
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}, {
-    object: string;
-    method: "delete";
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const DataEngineCountRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"count">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "count";
-    query?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "count";
-    query?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined;
-}>;
+        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>;
 export declare const DataEngineAggregateRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"aggregate">;
     object: z.ZodString;
     query: z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Group By fields */
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Aggregation definitions
-         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-         */
+        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>>;
         aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            method: z.ZodEnum<{
+                count: "count";
+                sum: "sum";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count_distinct: "count_distinct";
+            }>;
             alias: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    query: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    };
-    method: "aggregate";
-}, {
-    object: string;
-    query: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    };
-    method: "aggregate";
-}>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Data Engine Execute Request (Raw Command)
  * Execute a raw command/query native to the driver (e.g. SQL, Shell, Remote API).
  */
 export declare const DataEngineExecuteRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"execute">;
-    /** The abstract command (string SQL, or JSON object) */
     command: z.ZodAny;
-    /** Optional options */
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, "strip", z.ZodTypeAny, {
-    method: "execute";
-    options?: Record<string, any> | undefined;
-    command?: any;
-}, {
-    method: "execute";
-    options?: Record<string, any> | undefined;
-    command?: any;
-}>;
+}, z.core.$strip>;
 /**
  * Data Engine Vector Find Request (AI/RAG)
  * Perform a similarity search using vector embeddings.
@@ -928,1702 +276,345 @@ export declare const DataEngineExecuteRequestSchema: z.ZodObject<{
 export declare const DataEngineVectorFindRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"vectorFind">;
     object: z.ZodString;
-    /** The vector embedding to search for */
-    vector: z.ZodArray<z.ZodNumber, "many">;
-    /** Optional pre-filter (Metadata filtering) */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /** Fields to select */
-    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Number of results */
+    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>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    /** Minimum similarity score (0-1) or distance threshold */
     threshold: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    vector: number[];
-    method: "vectorFind";
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    threshold?: number | undefined;
-}, {
-    object: string;
-    vector: number[];
-    method: "vectorFind";
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    threshold?: number | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Data Engine Batch Request
  * Execute multiple operations in a single transaction/request efficiently.
  */
 export declare const DataEngineBatchRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"batch">;
-    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         method: z.ZodLiteral<"find">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Fields to select (SELECT) */
-            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Sort order (ORDER BY) */
-            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+            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<{
                 field: z.ZodString;
-                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                order: "asc" | "desc";
-            }, {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }>, "many">]>>;
-            /** Limit number of results (LIMIT) */
+                order: z.ZodDefault<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strip>>]>>;
             limit: z.ZodOptional<z.ZodNumber>;
-            /** Skip number of results (OFFSET) */
             skip: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Maximum number of results (OData style)
-             * Takes precedence over limit if both specified
-             */
             top: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Include related records (JOIN/Populate)
-             * List of relationship field names to expand
-             */
-            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }, {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"findOne">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Fields to select (SELECT) */
-            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Sort order (ORDER BY) */
-            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+            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<{
                 field: z.ZodString;
-                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                order: "asc" | "desc";
-            }, {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }>, "many">]>>;
-            /** Limit number of results (LIMIT) */
+                order: z.ZodDefault<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strip>>]>>;
             limit: z.ZodOptional<z.ZodNumber>;
-            /** Skip number of results (OFFSET) */
             skip: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Maximum number of results (OData style)
-             * Takes precedence over limit if both specified
-             */
             top: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Include related records (JOIN/Populate)
-             * List of relationship field names to expand
-             */
-            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }, {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"insert">;
         object: z.ZodString;
-        data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+        data: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
         options: z.ZodOptional<z.ZodObject<{
-            /**
-             * Return the inserted record(s)?
-             * Some drivers support RETURNING clause for efficiency.
-             * Default: true
-             */
             returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            returning?: boolean | undefined;
-        }, {
-            returning?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"update">;
         object: z.ZodString;
         data: z.ZodRecord<z.ZodString, z.ZodAny>;
         id: z.ZodOptional<z.ZodAny>;
         options: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions to identify records to update */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /**
-             * Perform an upsert?
-             * If true, insert if not found.
-             */
+            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>>]>>;
             upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-            /**
-             * Update multiple records?
-             * If false, only the first match is updated.
-             * Default: false
-             */
             multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-            /**
-             * Return the updated record(s)?
-             * Default: false (returns update count/status)
-             */
             returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }, {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"delete">;
         object: z.ZodString;
         id: z.ZodOptional<z.ZodAny>;
         options: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions to identify records to delete */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /**
-             * Delete multiple records?
-             * If false, only the first match is deleted.
-             * Default: false
-             */
+            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>>]>>;
             multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }, {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"count">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            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<{
         method: z.ZodLiteral<"aggregate">;
         object: z.ZodString;
         query: z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Group By fields */
-            groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /**
-             * Aggregation definitions
-             * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-             */
+            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>>;
             aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
-                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+                method: z.ZodEnum<{
+                    count: "count";
+                    sum: "sum";
+                    avg: "avg";
+                    min: "min";
+                    max: "max";
+                    count_distinct: "count_distinct";
+                }>;
                 alias: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }, {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }>, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    }, {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    }>, z.ZodObject<{
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"execute">;
-        /** The abstract command (string SQL, or JSON object) */
         command: z.ZodAny;
-        /** Optional options */
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strip", z.ZodTypeAny, {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    }, {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"vectorFind">;
         object: z.ZodString;
-        /** The vector embedding to search for */
-        vector: z.ZodArray<z.ZodNumber, "many">;
-        /** Optional pre-filter (Metadata filtering) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Number of results */
+        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>>;
         limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-        /** Minimum similarity score (0-1) or distance threshold */
         threshold: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    }, {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    }>]>, "many">;
-    /**
-     * Transaction Mode
-     * - true: All or nothing (Atomic)
-     * - false: Best effort, continue on error
-     */
+    }, z.core.$strip>], "method">>;
     transaction: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    method: "batch";
-    requests: ({
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    } | {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    } | {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    })[];
-    transaction?: boolean | undefined;
-}, {
-    method: "batch";
-    requests: ({
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    } | {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    } | {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    })[];
-    transaction?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Unified Data Engine Request Union
  * Use this to validate any incoming "Virtual ObjectQL" request.
  */
-export declare const DataEngineRequestSchema: z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+export declare const DataEngineRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     method: z.ZodLiteral<"find">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "find";
-    query?: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "find";
-    query?: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"findOne">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select (SELECT) */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Sort order (ORDER BY) */
-        sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+        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<{
             field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">]>>;
-        /** Limit number of results (LIMIT) */
+            order: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>]>>;
         limit: z.ZodOptional<z.ZodNumber>;
-        /** Skip number of results (OFFSET) */
         skip: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Maximum number of results (OData style)
-         * Takes precedence over limit if both specified
-         */
         top: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Include related records (JOIN/Populate)
-         * List of relationship field names to expand
-         */
-        populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }, {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "findOne";
-    query?: {
-        sort?: {
-            field: string;
-            order: "asc" | "desc";
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "findOne";
-    query?: {
-        sort?: {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        skip?: number | undefined;
-        top?: number | undefined;
-        populate?: string[] | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+        populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"insert">;
     object: z.ZodString;
-    data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+    data: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
     options: z.ZodOptional<z.ZodObject<{
-        /**
-         * Return the inserted record(s)?
-         * Some drivers support RETURNING clause for efficiency.
-         * Default: true
-         */
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        returning?: boolean | undefined;
-    }, {
-        returning?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "insert";
-    data: Record<string, any> | Record<string, any>[];
-    options?: {
-        returning?: boolean | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "insert";
-    data: Record<string, any> | Record<string, any>[];
-    options?: {
-        returning?: boolean | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"update">;
     object: z.ZodString;
     data: z.ZodRecord<z.ZodString, z.ZodAny>;
     id: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to update */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Perform an upsert?
-         * If true, insert if not found.
-         */
+        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>>]>>;
         upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Update multiple records?
-         * If false, only the first match is updated.
-         * Default: false
-         */
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        /**
-         * Return the updated record(s)?
-         * Default: false (returns update count/status)
-         */
         returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "update";
-    data: Record<string, any>;
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}, {
-    object: string;
-    method: "update";
-    data: Record<string, any>;
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        upsert?: boolean | undefined;
-        returning?: boolean | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}>, z.ZodObject<{
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"delete">;
     object: z.ZodString;
     id: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions to identify records to delete */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /**
-         * Delete multiple records?
-         * If false, only the first match is deleted.
-         * Default: false
-         */
+        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>>]>>;
         multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "delete";
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}, {
-    object: string;
-    method: "delete";
-    options?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        multi?: boolean | undefined;
-    } | undefined;
-    id?: any;
-}>, z.ZodObject<{
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"count">;
     object: z.ZodString;
     query: z.ZodOptional<z.ZodObject<{
-        /** Filter conditions */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    method: "count";
-    query?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined;
-}, {
-    object: string;
-    method: "count";
-    query?: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    } | undefined;
-}>, z.ZodObject<{
+        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<{
     method: z.ZodLiteral<"aggregate">;
     object: z.ZodString;
     query: z.ZodObject<{
-        /** Filter conditions (WHERE) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Group By fields */
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Aggregation definitions
-         * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-         */
+        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>>;
         aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
-            method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+            method: z.ZodEnum<{
+                count: "count";
+                sum: "sum";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count_distinct: "count_distinct";
+            }>;
             alias: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }, {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }, {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    query: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    };
-    method: "aggregate";
-}, {
-    object: string;
-    query: {
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        aggregations?: {
-            field: string;
-            method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-            alias?: string | undefined;
-        }[] | undefined;
-        groupBy?: string[] | undefined;
-    };
-    method: "aggregate";
-}>, z.ZodObject<{
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"batch">;
-    requests: z.ZodArray<z.ZodDiscriminatedUnion<"method", [z.ZodObject<{
+    requests: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         method: z.ZodLiteral<"find">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Fields to select (SELECT) */
-            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Sort order (ORDER BY) */
-            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+            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<{
                 field: z.ZodString;
-                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                order: "asc" | "desc";
-            }, {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }>, "many">]>>;
-            /** Limit number of results (LIMIT) */
+                order: z.ZodDefault<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strip>>]>>;
             limit: z.ZodOptional<z.ZodNumber>;
-            /** Skip number of results (OFFSET) */
             skip: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Maximum number of results (OData style)
-             * Takes precedence over limit if both specified
-             */
             top: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Include related records (JOIN/Populate)
-             * List of relationship field names to expand
-             */
-            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }, {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"findOne">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Fields to select (SELECT) */
-            select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Sort order (ORDER BY) */
-            sort: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<-1>]>>, z.ZodArray<z.ZodObject<{
+            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<{
                 field: z.ZodString;
-                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                order: "asc" | "desc";
-            }, {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }>, "many">]>>;
-            /** Limit number of results (LIMIT) */
+                order: z.ZodDefault<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strip>>]>>;
             limit: z.ZodOptional<z.ZodNumber>;
-            /** Skip number of results (OFFSET) */
             skip: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Maximum number of results (OData style)
-             * Takes precedence over limit if both specified
-             */
             top: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Include related records (JOIN/Populate)
-             * List of relationship field names to expand
-             */
-            populate: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }, {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            populate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"insert">;
         object: z.ZodString;
-        data: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">]>;
+        data: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>]>;
         options: z.ZodOptional<z.ZodObject<{
-            /**
-             * Return the inserted record(s)?
-             * Some drivers support RETURNING clause for efficiency.
-             * Default: true
-             */
             returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            returning?: boolean | undefined;
-        }, {
-            returning?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"update">;
         object: z.ZodString;
         data: z.ZodRecord<z.ZodString, z.ZodAny>;
         id: z.ZodOptional<z.ZodAny>;
         options: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions to identify records to update */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /**
-             * Perform an upsert?
-             * If true, insert if not found.
-             */
+            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>>]>>;
             upsert: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-            /**
-             * Update multiple records?
-             * If false, only the first match is updated.
-             * Default: false
-             */
             multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-            /**
-             * Return the updated record(s)?
-             * Default: false (returns update count/status)
-             */
             returning: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }, {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"delete">;
         object: z.ZodString;
         id: z.ZodOptional<z.ZodAny>;
         options: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions to identify records to delete */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /**
-             * Delete multiple records?
-             * If false, only the first match is deleted.
-             * Default: false
-             */
+            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>>]>>;
             multi: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }, {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    }>, z.ZodObject<{
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"count">;
         object: z.ZodString;
         query: z.ZodOptional<z.ZodObject<{
-            /** Filter conditions */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    }, {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    }>, z.ZodObject<{
+            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<{
         method: z.ZodLiteral<"aggregate">;
         object: z.ZodString;
         query: z.ZodObject<{
-            /** Filter conditions (WHERE) */
-            filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-            /** Group By fields */
-            groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /**
-             * Aggregation definitions
-             * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
-             */
+            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>>;
             aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
-                method: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct"]>;
+                method: z.ZodEnum<{
+                    count: "count";
+                    sum: "sum";
+                    avg: "avg";
+                    min: "min";
+                    max: "max";
+                    count_distinct: "count_distinct";
+                }>;
                 alias: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }, {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }>, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        }, {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    }, {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    }>, z.ZodObject<{
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"execute">;
-        /** The abstract command (string SQL, or JSON object) */
         command: z.ZodAny;
-        /** Optional options */
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strip", z.ZodTypeAny, {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    }, {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         method: z.ZodLiteral<"vectorFind">;
         object: z.ZodString;
-        /** The vector embedding to search for */
-        vector: z.ZodArray<z.ZodNumber, "many">;
-        /** Optional pre-filter (Metadata filtering) */
-        filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-        /** Fields to select */
-        select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Number of results */
+        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>>;
         limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-        /** Minimum similarity score (0-1) or distance threshold */
         threshold: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    }, {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    }>]>, "many">;
-    /**
-     * Transaction Mode
-     * - true: All or nothing (Atomic)
-     * - false: Best effort, continue on error
-     */
+    }, z.core.$strip>], "method">>;
     transaction: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    method: "batch";
-    requests: ({
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order: "asc" | "desc";
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    } | {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    } | {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    })[];
-    transaction?: boolean | undefined;
-}, {
-    method: "batch";
-    requests: ({
-        object: string;
-        method: "find";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "findOne";
-        query?: {
-            sort?: {
-                field: string;
-                order?: "asc" | "desc" | undefined;
-            }[] | Record<string, "asc" | "desc"> | Record<string, 1 | -1> | undefined;
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            limit?: number | undefined;
-            select?: string[] | undefined;
-            skip?: number | undefined;
-            top?: number | undefined;
-            populate?: string[] | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "insert";
-        data: Record<string, any> | Record<string, any>[];
-        options?: {
-            returning?: boolean | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        method: "update";
-        data: Record<string, any>;
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            upsert?: boolean | undefined;
-            returning?: boolean | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "delete";
-        options?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            multi?: boolean | undefined;
-        } | undefined;
-        id?: any;
-    } | {
-        object: string;
-        method: "count";
-        query?: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        } | undefined;
-    } | {
-        object: string;
-        query: {
-            filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-            aggregations?: {
-                field: string;
-                method: "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
-                alias?: string | undefined;
-            }[] | undefined;
-            groupBy?: string[] | undefined;
-        };
-        method: "aggregate";
-    } | {
-        method: "execute";
-        options?: Record<string, any> | undefined;
-        command?: any;
-    } | {
-        object: string;
-        vector: number[];
-        method: "vectorFind";
-        filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-        limit?: number | undefined;
-        select?: string[] | undefined;
-        threshold?: number | undefined;
-    })[];
-    transaction?: boolean | undefined;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"execute">;
-    /** The abstract command (string SQL, or JSON object) */
     command: z.ZodAny;
-    /** Optional options */
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, "strip", z.ZodTypeAny, {
-    method: "execute";
-    options?: Record<string, any> | undefined;
-    command?: any;
-}, {
-    method: "execute";
-    options?: Record<string, any> | undefined;
-    command?: any;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"vectorFind">;
     object: z.ZodString;
-    /** The vector embedding to search for */
-    vector: z.ZodArray<z.ZodNumber, "many">;
-    /** Optional pre-filter (Metadata filtering) */
-    filter: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>]>>;
-    /** Fields to select */
-    select: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Number of results */
+    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>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    /** Minimum similarity score (0-1) or distance threshold */
     threshold: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    object: string;
-    vector: number[];
-    method: "vectorFind";
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    threshold?: number | undefined;
-}, {
-    object: string;
-    vector: number[];
-    method: "vectorFind";
-    filter?: Record<string, any> | import("./filter.zod").FilterCondition | undefined;
-    limit?: number | undefined;
-    select?: string[] | undefined;
-    threshold?: number | undefined;
-}>]>;
+}, z.core.$strip>], "method">;
 export type DataEngineFilter = z.infer<typeof DataEngineFilterSchema>;
 export type DataEngineSort = z.infer<typeof DataEngineSortSchema>;
 export type DataEngineQueryOptions = z.infer<typeof DataEngineQueryOptionsSchema>;