@arizeai/phoenix-client 1.0.0 → 1.0.2

package/dist/src/schemas/llm/openai/converters.d.ts

@@ -3504,4 +3504,1696 @@ export declare const openAIToolDefinitionToAnthropic: import("zod").ZodEffects<i
         }>, import("zod").ZodTypeAny, "passthrough">>;
     }, import("zod").ZodTypeAny, "passthrough">>;
 }, import("zod").ZodTypeAny, "passthrough">>;
+/**
+ * Parse incoming object as an OpenAI tool definition and immediately convert to Vercel AI format
+ */
+export declare const openAIToolDefinitionToVercelAI: import("zod").ZodEffects<import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"function">;
+    function: import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+    type: import("zod").ZodLiteral<"function">;
+    function: import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+    type: import("zod").ZodLiteral<"function">;
+    function: import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+}, import("zod").ZodTypeAny, "passthrough">>, {
+    type: "function";
+    parameters: {
+        _type?: unknown;
+        validate?: unknown;
+        jsonSchema?: Record<string, unknown> | undefined;
+    };
+    description?: string | undefined;
+}, import("zod").objectInputType<{
+    type: import("zod").ZodLiteral<"function">;
+    function: import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            type: import("zod").ZodLiteral<"object">;
+            properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                anyOf: import("zod").ZodArray<import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", import("zod").ZodTypeAny, {
+                anyOf: import("zod").objectOutputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }, {
+                anyOf: import("zod").objectInputType<{
+                    type: import("zod").ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+            }>]>>;
+            required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, {
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }>, import("zod").ZodTypeAny, "passthrough">>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+}, import("zod").ZodTypeAny, "passthrough">>;
 //# sourceMappingURL=converters.d.ts.map