@arizeai/phoenix-client 0.0.1 → 1.0.0

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

@@ -0,0 +1,1497 @@
+export declare const anthropicMessagePartToOpenAI: import("zod").ZodEffects<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"text">;
+    text: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    text: string;
+    type: "text";
+}, {
+    text: string;
+    type: "text";
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"image">;
+    source: import("zod").ZodObject<{
+        data: import("zod").ZodString;
+        media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+        type: import("zod").ZodLiteral<"base64">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "base64";
+        data: string;
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    }, {
+        type: "base64";
+        data: string;
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    }>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "image";
+    source: {
+        type: "base64";
+        data: string;
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    };
+}, {
+    type: "image";
+    source: {
+        type: "base64";
+        data: string;
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    };
+}>, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    type: import("zod").ZodLiteral<"tool_use">;
+    name: import("zod").ZodString;
+    input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+}, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"tool_result">;
+    tool_use_id: import("zod").ZodString;
+    content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image">;
+        source: import("zod").ZodObject<{
+            data: import("zod").ZodString;
+            media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+            type: import("zod").ZodLiteral<"base64">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }>]>, "many">]>;
+    is_error: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "tool_result";
+    content: string | ({
+        text: string;
+        type: "text";
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    })[];
+    tool_use_id: string;
+    is_error?: boolean | undefined;
+}, {
+    type: "tool_result";
+    content: string | ({
+        text: string;
+        type: "text";
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    })[];
+    tool_use_id: string;
+    is_error?: boolean | undefined;
+}>]>, {
+    text: string;
+    type: "text";
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+} | null, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+} | {
+    text: string;
+    type: "text";
+} | {
+    type: "image";
+    source: {
+        type: "base64";
+        data: string;
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    };
+} | {
+    type: "tool_result";
+    content: string | ({
+        text: string;
+        type: "text";
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    })[];
+    tool_use_id: string;
+    is_error?: boolean | undefined;
+}>;
+/**
+ * Spoke → Hub: Convert an Anthropic message to OpenAI format
+ */
+export declare const anthropicMessageToOpenAI: import("zod").ZodEffects<import("zod").ZodObject<{
+    role: import("zod").ZodEnum<["user", "assistant"]>;
+    content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image">;
+        source: import("zod").ZodObject<{
+            data: import("zod").ZodString;
+            media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+            type: import("zod").ZodLiteral<"base64">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"tool_use">;
+        name: import("zod").ZodString;
+        input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool_result">;
+        tool_use_id: import("zod").ZodString;
+        content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            source: import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+                type: import("zod").ZodLiteral<"base64">;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }>]>, "many">]>;
+        is_error: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }>]>, "many">]>;
+}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+    role: import("zod").ZodEnum<["user", "assistant"]>;
+    content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image">;
+        source: import("zod").ZodObject<{
+            data: import("zod").ZodString;
+            media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+            type: import("zod").ZodLiteral<"base64">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"tool_use">;
+        name: import("zod").ZodString;
+        input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool_result">;
+        tool_use_id: import("zod").ZodString;
+        content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            source: import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+                type: import("zod").ZodLiteral<"base64">;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }>]>, "many">]>;
+        is_error: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }>]>, "many">]>;
+}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+    role: import("zod").ZodEnum<["user", "assistant"]>;
+    content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image">;
+        source: import("zod").ZodObject<{
+            data: import("zod").ZodString;
+            media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+            type: import("zod").ZodLiteral<"base64">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"tool_use">;
+        name: import("zod").ZodString;
+        input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool_result">;
+        tool_use_id: import("zod").ZodString;
+        content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            source: import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+                type: import("zod").ZodLiteral<"base64">;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }>]>, "many">]>;
+        is_error: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }>]>, "many">]>;
+}, import("zod").ZodTypeAny, "passthrough">>, import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"assistant">;
+    content: import("zod").ZodUnion<[import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, "many">, import("zod").ZodString]>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    tool_call_id: import("zod").ZodOptional<import("zod").ZodString>;
+    tool_calls: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodEffects<import("zod").ZodOptional<import("zod").ZodLiteral<"function">>, "function", "function" | undefined>;
+        id: import("zod").ZodString;
+        function: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            arguments: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            name: import("zod").ZodString;
+            arguments: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            name: import("zod").ZodString;
+            arguments: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+    }, "strip", import("zod").ZodTypeAny, {
+        function: {
+            name: string;
+            arguments: string;
+        } & {
+            [k: string]: unknown;
+        };
+        type: "function";
+        id: string;
+    }, {
+        function: {
+            name: string;
+            arguments: string;
+        } & {
+            [k: string]: unknown;
+        };
+        id: string;
+        type?: "function" | undefined;
+    }>, "many">>;
+}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"tool">;
+    content: import("zod").ZodUnion<[import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, "many">, import("zod").ZodString]>;
+    tool_call_id: import("zod").ZodString;
+}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"function">;
+    content: import("zod").ZodNullable<import("zod").ZodString>;
+    name: import("zod").ZodString;
+}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"user">;
+    content: import("zod").ZodUnion<[import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image_url">;
+        image_url: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            url: string;
+        }, {
+            url: string;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image_url";
+        image_url: {
+            url: string;
+        };
+    }, {
+        type: "image_url";
+        image_url: {
+            url: string;
+        };
+    }>]>, "many">, import("zod").ZodString]>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"system">;
+    content: import("zod").ZodUnion<[import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, "many">, import("zod").ZodString]>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+    role: import("zod").ZodLiteral<"developer">;
+    content: import("zod").ZodUnion<[import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, "many">, import("zod").ZodString]>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+    role: import("zod").ZodEnum<["user", "assistant"]>;
+    content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text">;
+        text: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        type: "text";
+    }, {
+        text: string;
+        type: "text";
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"image">;
+        source: import("zod").ZodObject<{
+            data: import("zod").ZodString;
+            media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+            type: import("zod").ZodLiteral<"base64">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }, {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            data: string;
+            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        };
+    }>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"tool_use">;
+        name: import("zod").ZodString;
+        input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }, {
+        type: "tool_use";
+        input: import("../../jsonLiteralSchema").JSONLiteral;
+        id: string;
+        name: string;
+    }>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool_result">;
+        tool_use_id: import("zod").ZodString;
+        content: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            text: string;
+            type: "text";
+        }, {
+            text: string;
+            type: "text";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            source: import("zod").ZodObject<{
+                data: import("zod").ZodString;
+                media_type: import("zod").ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
+                type: import("zod").ZodLiteral<"base64">;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }, {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        }>]>, "many">]>;
+        is_error: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        content: string | ({
+            text: string;
+            type: "text";
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                data: string;
+                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+            };
+        })[];
+        tool_use_id: string;
+        is_error?: boolean | undefined;
+    }>]>, "many">]>;
+}, import("zod").ZodTypeAny, "passthrough">>;
+/**
+ * Parse incoming object as an Anthropic tool call and immediately convert to OpenAI format
+ */
+export declare const anthropicToolCallToOpenAI: import("zod").ZodEffects<import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    type: import("zod").ZodLiteral<"tool_use">;
+    name: import("zod").ZodString;
+    input: import("zod").ZodType<import("../../jsonLiteralSchema").JSONLiteral, import("zod").ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+}, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+}>, {
+    function: {
+        name: string;
+        arguments: string;
+    } & {
+        [k: string]: unknown;
+    };
+    type: "function";
+    id: string;
+}, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema").JSONLiteral;
+    id: string;
+    name: string;
+}>;
+/**
+ * Parse incoming object as an Anthropic tool choice and immediately convert to OpenAI format
+ */
+export declare const anthropicToolChoiceToOpenAI: import("zod").ZodEffects<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"tool">;
+    name: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "tool";
+    name: string;
+}, {
+    type: "tool";
+    name: string;
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"auto">;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "auto";
+}, {
+    type: "auto";
+}>, import("zod").ZodObject<{
+    type: import("zod").ZodLiteral<"any">;
+}, "strip", import("zod").ZodTypeAny, {
+    type: "any";
+}, {
+    type: "any";
+}>]>, "none" | "auto" | "required" | {
+    function: {
+        name: string;
+    };
+    type: "function";
+}, {
+    type: "tool";
+    name: string;
+} | {
+    type: "auto";
+} | {
+    type: "any";
+}>;
+/**
+ * Parse incoming object as an Anthropic tool call and immediately convert to OpenAI format
+ */
+export declare const anthropicToolDefinitionToOpenAI: import("zod").ZodEffects<import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    description: import("zod").ZodString;
+    input_schema: import("zod").ZodObject<{
+        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>;
+    }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+        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>;
+    }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+        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>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
+}, "strip", import("zod").ZodTypeAny, {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, 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").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">[];
+        }>;
+        required?: string[] | undefined;
+        additionalProperties?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, 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"> | {
+            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?: string[] | undefined;
+        additionalProperties?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}>, 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">, {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, 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"> | {
+            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?: string[] | undefined;
+        additionalProperties?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}>;
+//# sourceMappingURL=converters.d.ts.map