@objectstack/spec 0.6.0 → 0.7.1

package/dist/api/batch.zod.d.ts

@@ -0,0 +1,1029 @@
+import { z } from 'zod';
+/**
+ * Batch Operations API
+ *
+ * Provides efficient bulk data operations with transaction support.
+ * Implements P0/P1 requirements for ObjectStack kernel.
+ *
+ * Features:
+ * - Batch create/update/delete operations
+ * - Atomic transaction support (all-or-none)
+ * - Partial success handling
+ * - Detailed error reporting per record
+ *
+ * Industry alignment: Salesforce Bulk API, Microsoft Dynamics Bulk Operations
+ */
+/**
+ * Batch Operation Type Enum
+ * Defines the type of batch operation to perform
+ */
+export declare const BatchOperationType: z.ZodEnum<["create", "update", "upsert", "delete"]>;
+export type BatchOperationType = z.infer<typeof BatchOperationType>;
+/**
+ * Batch Record Schema
+ * Individual record in a batch operation
+ */
+export declare const BatchRecordSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    externalId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    externalId?: string | undefined;
+    id?: string | undefined;
+    data?: Record<string, any> | undefined;
+}, {
+    externalId?: string | undefined;
+    id?: string | undefined;
+    data?: Record<string, any> | undefined;
+}>;
+export type BatchRecord = z.infer<typeof BatchRecordSchema>;
+/**
+ * Batch Operation Options Schema
+ * Configuration options for batch operations
+ */
+export declare const BatchOptionsSchema: z.ZodObject<{
+    atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    atomic: boolean;
+    continueOnError: boolean;
+    validateOnly: boolean;
+    returnRecords: boolean;
+}, {
+    atomic?: boolean | undefined;
+    continueOnError?: boolean | undefined;
+    validateOnly?: boolean | undefined;
+    returnRecords?: boolean | undefined;
+}>;
+export type BatchOptions = z.infer<typeof BatchOptionsSchema>;
+/**
+ * Batch Update Request Schema
+ * Request payload for batch update operations
+ *
+ * @example
+ * // POST /api/v1/data/{object}/batch
+ * {
+ *   "operation": "update",
+ *   "records": [
+ *     { "id": "1", "data": { "name": "Updated Name 1", "status": "active" } },
+ *     { "id": "2", "data": { "name": "Updated Name 2", "status": "active" } }
+ *   ],
+ *   "options": {
+ *     "atomic": true,
+ *     "returnRecords": true
+ *   }
+ * }
+ */
+export declare const BatchUpdateRequestSchema: z.ZodObject<{
+    operation: z.ZodEnum<["create", "update", "upsert", "delete"]>;
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        externalId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }, {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }>, "many">;
+    options: z.ZodOptional<z.ZodObject<{
+        atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    }, {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    records: {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[];
+    operation: "update" | "delete" | "create" | "upsert";
+    options?: {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    } | undefined;
+}, {
+    records: {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[];
+    operation: "update" | "delete" | "create" | "upsert";
+    options?: {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    } | undefined;
+}>;
+export type BatchUpdateRequest = z.input<typeof BatchUpdateRequestSchema>;
+/**
+ * Simplified Batch Update Request (for updateMany API)
+ * Simplified request for batch updates without operation field
+ *
+ * @example
+ * // POST /api/v1/data/{object}/updateMany
+ * {
+ *   "records": [
+ *     { "id": "1", "data": { "name": "Updated Name 1" } },
+ *     { "id": "2", "data": { "name": "Updated Name 2" } }
+ *   ],
+ *   "options": { "atomic": true }
+ * }
+ */
+export declare const UpdateManyRequestSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        externalId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }, {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }>, "many">;
+    options: z.ZodOptional<z.ZodObject<{
+        atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    }, {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    records: {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[];
+    options?: {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    } | undefined;
+}, {
+    records: {
+        externalId?: string | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+    }[];
+    options?: {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    } | undefined;
+}>;
+export type UpdateManyRequest = z.input<typeof UpdateManyRequestSchema>;
+/**
+ * Batch Operation Result Schema
+ * Result for a single record in a batch operation
+ */
+export declare const BatchOperationResultSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    success: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: string;
+        details?: any;
+    }, {
+        message: string;
+        code: string;
+        details?: any;
+    }>, "many">>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    index: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    index?: number | undefined;
+    id?: string | undefined;
+    data?: Record<string, any> | undefined;
+    errors?: {
+        message: string;
+        code: string;
+        details?: any;
+    }[] | undefined;
+}, {
+    success: boolean;
+    index?: number | undefined;
+    id?: string | undefined;
+    data?: Record<string, any> | undefined;
+    errors?: {
+        message: string;
+        code: string;
+        details?: any;
+    }[] | undefined;
+}>;
+export type BatchOperationResult = z.infer<typeof BatchOperationResultSchema>;
+/**
+ * Batch Update Response Schema
+ * Response payload for batch operations
+ *
+ * @example Success Response
+ * {
+ *   "success": true,
+ *   "operation": "update",
+ *   "total": 2,
+ *   "succeeded": 2,
+ *   "failed": 0,
+ *   "results": [
+ *     { "id": "1", "success": true, "index": 0 },
+ *     { "id": "2", "success": true, "index": 1 }
+ *   ],
+ *   "meta": {
+ *     "timestamp": "2026-01-29T12:00:00Z",
+ *     "duration": 150
+ *   }
+ * }
+ *
+ * @example Partial Success Response (atomic=false)
+ * {
+ *   "success": false,
+ *   "operation": "update",
+ *   "total": 2,
+ *   "succeeded": 1,
+ *   "failed": 1,
+ *   "results": [
+ *     { "id": "1", "success": true, "index": 0 },
+ *     {
+ *       "success": false,
+ *       "index": 1,
+ *       "errors": [{ "code": "validation_error", "message": "Invalid email format" }]
+ *     }
+ *   ],
+ *   "meta": {
+ *     "timestamp": "2026-01-29T12:00:00Z"
+ *   }
+ * }
+ */
+export declare const BatchUpdateResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: string;
+        details?: any;
+    }, {
+        message: string;
+        code: string;
+        details?: any;
+    }>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodString;
+        duration: z.ZodOptional<z.ZodNumber>;
+        requestId: z.ZodOptional<z.ZodString>;
+        traceId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        duration?: number | undefined;
+        requestId?: string | undefined;
+        traceId?: string | undefined;
+    }, {
+        timestamp: string;
+        duration?: number | undefined;
+        requestId?: string | undefined;
+        traceId?: string | undefined;
+    }>>;
+} & {
+    operation: z.ZodOptional<z.ZodEnum<["create", "update", "upsert", "delete"]>>;
+    total: z.ZodNumber;
+    succeeded: z.ZodNumber;
+    failed: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        success: z.ZodBoolean;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodOptional<z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            code: string;
+            details?: any;
+        }, {
+            message: string;
+            code: string;
+            details?: any;
+        }>, "many">>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        index: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        index?: number | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+        errors?: {
+            message: string;
+            code: string;
+            details?: any;
+        }[] | undefined;
+    }, {
+        success: boolean;
+        index?: number | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+        errors?: {
+            message: string;
+            code: string;
+            details?: any;
+        }[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    success: boolean;
+    failed: number;
+    results: {
+        success: boolean;
+        index?: number | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+        errors?: {
+            message: string;
+            code: string;
+            details?: any;
+        }[] | undefined;
+    }[];
+    succeeded: number;
+    error?: {
+        message: string;
+        code: string;
+        details?: any;
+    } | undefined;
+    operation?: "update" | "delete" | "create" | "upsert" | undefined;
+    meta?: {
+        timestamp: string;
+        duration?: number | undefined;
+        requestId?: string | undefined;
+        traceId?: string | undefined;
+    } | undefined;
+}, {
+    total: number;
+    success: boolean;
+    failed: number;
+    results: {
+        success: boolean;
+        index?: number | undefined;
+        id?: string | undefined;
+        data?: Record<string, any> | undefined;
+        errors?: {
+            message: string;
+            code: string;
+            details?: any;
+        }[] | undefined;
+    }[];
+    succeeded: number;
+    error?: {
+        message: string;
+        code: string;
+        details?: any;
+    } | undefined;
+    operation?: "update" | "delete" | "create" | "upsert" | undefined;
+    meta?: {
+        timestamp: string;
+        duration?: number | undefined;
+        requestId?: string | undefined;
+        traceId?: string | undefined;
+    } | undefined;
+}>;
+export type BatchUpdateResponse = z.infer<typeof BatchUpdateResponseSchema>;
+/**
+ * Batch Delete Request Schema
+ * Simplified request for batch delete operations
+ *
+ * @example
+ * // POST /api/v1/data/{object}/deleteMany
+ * {
+ *   "ids": ["1", "2", "3"],
+ *   "options": { "atomic": true }
+ * }
+ */
+export declare const DeleteManyRequestSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString, "many">;
+    options: z.ZodOptional<z.ZodObject<{
+        atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    }, {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    ids: string[];
+    options?: {
+        atomic: boolean;
+        continueOnError: boolean;
+        validateOnly: boolean;
+        returnRecords: boolean;
+    } | undefined;
+}, {
+    ids: string[];
+    options?: {
+        atomic?: boolean | undefined;
+        continueOnError?: boolean | undefined;
+        validateOnly?: boolean | undefined;
+        returnRecords?: boolean | undefined;
+    } | undefined;
+}>;
+export type DeleteManyRequest = z.infer<typeof DeleteManyRequestSchema>;
+/**
+ * Batch API Contracts
+ * Standardized contracts for batch operations
+ */
+export declare const BatchApiContracts: {
+    batchOperation: {
+        input: z.ZodObject<{
+            operation: z.ZodEnum<["create", "update", "upsert", "delete"]>;
+            records: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                externalId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }, {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }>, "many">;
+            options: z.ZodOptional<z.ZodObject<{
+                atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            }, {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            records: {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }[];
+            operation: "update" | "delete" | "create" | "upsert";
+            options?: {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            } | undefined;
+        }, {
+            records: {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }[];
+            operation: "update" | "delete" | "create" | "upsert";
+            options?: {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            } | undefined;
+        }>;
+        output: z.ZodObject<{
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                details?: any;
+            }, {
+                message: string;
+                code: string;
+                details?: any;
+            }>>;
+            meta: z.ZodOptional<z.ZodObject<{
+                timestamp: z.ZodString;
+                duration: z.ZodOptional<z.ZodNumber>;
+                requestId: z.ZodOptional<z.ZodString>;
+                traceId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }>>;
+        } & {
+            operation: z.ZodOptional<z.ZodEnum<["create", "update", "upsert", "delete"]>>;
+            total: z.ZodNumber;
+            succeeded: z.ZodNumber;
+            failed: z.ZodNumber;
+            results: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                success: z.ZodBoolean;
+                errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    details: z.ZodOptional<z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }>, "many">>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                index: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }>;
+    };
+    updateMany: {
+        input: z.ZodObject<{
+            records: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                externalId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }, {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }>, "many">;
+            options: z.ZodOptional<z.ZodObject<{
+                atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            }, {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            records: {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }[];
+            options?: {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            } | undefined;
+        }, {
+            records: {
+                externalId?: string | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+            }[];
+            options?: {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            } | undefined;
+        }>;
+        output: z.ZodObject<{
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                details?: any;
+            }, {
+                message: string;
+                code: string;
+                details?: any;
+            }>>;
+            meta: z.ZodOptional<z.ZodObject<{
+                timestamp: z.ZodString;
+                duration: z.ZodOptional<z.ZodNumber>;
+                requestId: z.ZodOptional<z.ZodString>;
+                traceId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }>>;
+        } & {
+            operation: z.ZodOptional<z.ZodEnum<["create", "update", "upsert", "delete"]>>;
+            total: z.ZodNumber;
+            succeeded: z.ZodNumber;
+            failed: z.ZodNumber;
+            results: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                success: z.ZodBoolean;
+                errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    details: z.ZodOptional<z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }>, "many">>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                index: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }>;
+    };
+    deleteMany: {
+        input: z.ZodObject<{
+            ids: z.ZodArray<z.ZodString, "many">;
+            options: z.ZodOptional<z.ZodObject<{
+                atomic: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                returnRecords: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                continueOnError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                validateOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            }, {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            ids: string[];
+            options?: {
+                atomic: boolean;
+                continueOnError: boolean;
+                validateOnly: boolean;
+                returnRecords: boolean;
+            } | undefined;
+        }, {
+            ids: string[];
+            options?: {
+                atomic?: boolean | undefined;
+                continueOnError?: boolean | undefined;
+                validateOnly?: boolean | undefined;
+                returnRecords?: boolean | undefined;
+            } | undefined;
+        }>;
+        output: z.ZodObject<{
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                details?: any;
+            }, {
+                message: string;
+                code: string;
+                details?: any;
+            }>>;
+            meta: z.ZodOptional<z.ZodObject<{
+                timestamp: z.ZodString;
+                duration: z.ZodOptional<z.ZodNumber>;
+                requestId: z.ZodOptional<z.ZodString>;
+                traceId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }, {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            }>>;
+        } & {
+            operation: z.ZodOptional<z.ZodEnum<["create", "update", "upsert", "delete"]>>;
+            total: z.ZodNumber;
+            succeeded: z.ZodNumber;
+            failed: z.ZodNumber;
+            results: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                success: z.ZodBoolean;
+                errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    details: z.ZodOptional<z.ZodAny>;
+                }, "strip", z.ZodTypeAny, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }, {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }>, "many">>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                index: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }, {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }, {
+            total: number;
+            success: boolean;
+            failed: number;
+            results: {
+                success: boolean;
+                index?: number | undefined;
+                id?: string | undefined;
+                data?: Record<string, any> | undefined;
+                errors?: {
+                    message: string;
+                    code: string;
+                    details?: any;
+                }[] | undefined;
+            }[];
+            succeeded: number;
+            error?: {
+                message: string;
+                code: string;
+                details?: any;
+            } | undefined;
+            operation?: "update" | "delete" | "create" | "upsert" | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        }>;
+    };
+};
+//# sourceMappingURL=batch.zod.d.ts.map