@langchain/core 1.0.0-alpha.5 → 1.0.0-alpha.6

package/dist/utils/types/zod.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.cts","names":["z3","z4","ZodStringV3","ZodString","ZodStringV4","$ZodType","ZodObjectV3","ZodObject","ZodObjectV4","$ZodObject","InteropZodType","Output","ZodTypeDef","Input","ZodType","InteropZodObject","InteropZodObjectShape","T","Shape","K","InteropZodIssue","ZodIssue","$ZodIssue","InferInteropZodInput","InferInteropZodOutput","Mutable","P","isZodSchemaV4","isZodSchemaV3","isZodSchema","Record","RunOutput","isInteropZodSchema","InteropZodSafeParseResult","SafeParseReturnType","interopSafeParseAsync","Promise","interopParseAsync","interopSafeParse","interopParse","getSchemaDescription","isShapelessZodSchema","isSimpleStringZodSchema","isZodObjectV3","isZodObjectV4","isZodArrayV4","$ZodArray","isInteropZodObject","getInteropZodObjectShape","extendInteropZodObject","interopZodObjectPartial","interopZodObjectStrict","interopZodObjectPassthrough","getInteropZodDefaultGetter","interopZodTransformInputSchema"],"sources":["../../../src/utils/types/zod.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nexport type ZodStringV3 = z3.ZodString;\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\nexport type ZodObjectV4 = z4.$ZodObject;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\nexport type InteropZodObjectShape<T extends InteropZodObject = InteropZodObject> = T extends z3.ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : T extends z4.$ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : never;\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<unknown, z3.ZodTypeDef, infer Input> ? Input : T extends z4.$ZodType<unknown, infer Input> ? Input : T extends {\n    _zod: {\n        input: infer Input;\n    };\n} ? Input : never;\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.ZodTypeDef, unknown> ? Output : T extends z4.$ZodType<infer Output, unknown> ? Output : T extends {\n    _zod: {\n        output: infer Output;\n    };\n} ? Output : never;\nexport type Mutable<T> = {\n    -readonly [P in keyof T]: T[P];\n};\nexport declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;\nexport declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;\n/** Backward compatible isZodSchema for Zod 3 */\nexport declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(schema: z3.ZodType<RunOutput> | Record<string, unknown>): schema is z3.ZodType<RunOutput>;\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport declare function isInteropZodSchema(input: unknown): input is InteropZodType;\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<InteropZodSafeParseResult<T>>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<T>;\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParse<T>(schema: InteropZodType<T>, input: unknown): InteropZodSafeParseResult<T>;\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParse<T>(schema: InteropZodType<T>, input: unknown): T;\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport declare function getSchemaDescription(schema: InteropZodType<unknown> | Record<string, unknown>): string | undefined;\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport declare function isShapelessZodSchema(schema: unknown): boolean;\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;\nexport declare function isZodObjectV3(obj: unknown): obj is ZodObjectV3;\nexport declare function isZodObjectV4(obj: unknown): obj is z4.$ZodObject;\nexport declare function isZodArrayV4(obj: unknown): obj is z4.$ZodArray;\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport declare function isInteropZodObject(obj: unknown): obj is InteropZodObject;\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function getInteropZodObjectShape<T extends InteropZodObject>(schema: T): InteropZodObjectShape<T>;\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function extendInteropZodObject<T extends InteropZodObject>(schema: T, extension: InteropZodObjectShape): InteropZodObject;\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectStrict<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport declare function interopZodTransformInputSchema(schema: InteropZodType, recursive?: boolean): InteropZodType;\nexport {};\n"],"mappings":";;;;KAEYE,WAAAA,GAAcF,EAAAA,CAAGG;KACjBC,WAAAA,GAAcH,EAAAA,CAAGI;AAD7B;AACYD,KAEAE,WAAAA,GAAcN,EAAAA,CAAGO,SAFAF,CAAAA,GAAQ,EAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA;AAEzBC,KACAE,WAAAA,GAAcP,EAAAA,CAAGQ,UADAF;AAC7B;AAEYG,KAAAA,cAAc,CAAA,SAAA,GAAA,EAAA,QAAuBC,MAAvB,CAAA,GAAiCX,EAAAA,CAAGc,OAApC,CAA4CH,MAA5C,EAAoDX,EAAAA,CAAGY,UAAvD,EAAmEC,KAAnE,CAAA,GAA4EZ,EAAAA,CAAGI,QAA/E,CAAwFM,MAAxF,EAAgGE,KAAhG,CAAA;AAAA,KACdE,gBAAAA,GAAmBT,WADL,GACmBE,WADnB;AAAuBG,KAErCK,qBAFqCL,CAAAA,UAELI,gBAFKJ,GAEcI,gBAFdJ,CAAAA,GAEkCM,CAFlCN,SAE4CX,EAAAA,CAAGO,SAF/CI,CAAAA,KAAAA,MAAAA,CAAAA,GAAAA,QAAqBA,MAGtDO,KAHsDP,GAG9CO,KAH8CP,CAGxCQ,CAHwCR,CAAAA,EAAM,GAIxEM,CAJwE,SAI9DhB,EAAAA,CAAGQ,UAJgEG,CAAAA,KAAAA,MAAAA,CAAAA,GAAAA,QAAYC,MAK7EK,KAL6EL,GAKrEK,KALqEL,CAK/DM,CAL+DN,CAAAA,EAAK,GAAA,KAAvCb;AAAuDW,KAOtGS,eAAAA,GAAkBpB,EAAAA,CAAGqB,QAPiFV,GAOtEV,EAAAA,CAAGqB,SAPmEX;;AAAZV,KAS1FsB,oBAT6FlB,CAAAA,CAAAA,CAAAA,GASnEY,CATmEZ,SASzDL,EAAAA,CAAGc,OATsDT,CAAAA,OAAAA,EASrCL,EAAAA,CAAGY,UATkCP,EAAAA,KAAAA,MAAAA,CAAAA,GASPQ,KATOR,GASCY,CATDZ,SASWJ,EAAAA,CAAGI,QATdA,CAAAA,OAAAA,EAAAA,KAAAA,MAAAA,CAAAA,GAS+CQ,KAT/CR,GASuDY,CATvDZ,SAAAA;EAAQ,IAAA,EAAA;IACrGU,KAAAA,EAAAA,KAAAA,MAAgB;EAAA,CAAA;CAAA,GAYxBF,KAZ2BP,GAAAA,KAAAA;AAAcE,KAajCgB,qBAbiChB,CAAAA,CAAAA,CAAAA,GAaNS,CAbMT,SAaIR,EAAAA,CAAGc,OAbPN,CAAAA,KAAAA,OAAAA,EAa6BR,EAAAA,CAAGY,UAbhCJ,EAAAA,OAAAA,CAAAA,GAauDG,MAbvDH,GAagES,CAbhET,SAa0EP,EAAAA,CAAGI,QAb7EG,CAAAA,KAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAa+GG,MAb/GH,GAawHS,CAbxHT,SAAAA;EAAW,IAAA,EAAA;IAC5CQ,MAAAA,EAAAA,KAAAA,OAAqB;EAAA,CAAA;CAAA,GAgB7BL,MAhBwCI,GAAAA,KAAAA;AAAmBA,KAiBnDU,OAjBmDV,CAAAA,CAAAA,CAAAA,GAAAA,kBAAoBE,MAkBzDA,CAlByDA,GAkBrDA,CAlBqDA,CAkBnDS,CAlBmDT,CAAAA,EAAC;AACpEC,iBAmBQS,aAAAA,CAnBRT,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,IAmBkDjB,EAAAA,CAAGI,QAnBrDa,CAAAA,OAAAA,EAAAA,OAAAA,CAAAA;AAAQA,iBAoBAU,aAAAA,CApBAV,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,IAoB0ClB,EAAAA,CAAGc,OApB7CI,CAAAA,OAAAA,EAoB8DlB,EAAAA,CAAGY,UApBjEM,EAAAA,OAAAA,CAAAA;;AACpBD,iBAqBoBY,WArBpBZ,CAAAA,kBAqBkDa,MArBlDb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAqB4Ea,MArB5Eb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAqB6GjB,EAAAA,CAAGc,OArBhHG,CAqBwHc,SArBxHd,CAAAA,GAqBqIa,MArBrIb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA,IAqByKjB,EAAAA,CAAGc,OArB5KG,CAqBoLc,SArBpLd,CAAAA;;;;;AAC2B;AAE/B;AAA2B,iBAyBHe,kBAAAA,CAzBG,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAyB0CtB,cAzB1C;KA0BtBuB,yBA1B4BZ,CAAAA,CAAAA,CAAAA,GA0BGrB,EAAAA,CAAGkC,mBA1BNb,CA0B0BJ,CA1B1BI,EA0B6BJ,CA1B7BI,CAAAA;;AAAuB;AAExD;;;;;;;;AAAwJR,iBAmChIsB,qBAnCgItB,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAmC/FH,cAnC+FG,CAmChFI,CAnCgFJ,CAAAA,EAAAA,KAAAA,EAAAA,OAAAA,CAAAA,EAmC3DuB,OAnC2DvB,CAmCnDoB,yBAnCmDpB,CAmCzBI,CAnCyBJ,CAAAA,CAAAA;;;AAI/I;AACT;;;;;;;AAAuHZ,iBAyC/FoC,iBAzCkGhC,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAyCrEK,cAzCqEL,CAyCtDY,CAzCsDZ,CAAAA,EAAAA,KAAAA,EAAAA,OAAAA,CAAAA,EAyCjC+B,OAzCiC/B,CAyCzBY,CAzCyBZ,CAAAA;;;;AAIhH;AACV;;;;;AACiC;AAEjC;AACwBuB,iBA4CAU,gBA5Ca,CAAA,CAAA,CAAA,CAAA,MAAA,EA4Ce5B,cA5Cf,CA4C8BO,CA5C9B,CAAA,EAAA,KAAA,EAAA,OAAA,CAAA,EA4CmDgB,yBA5CnD,CA4C6EhB,CA5C7E,CAAA;;;;AAAuC;AAE5E;;;;;;AAAyIa,iBAqDjHS,YArDiHT,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAqDzFpB,cArDyFoB,CAqD1Eb,CArD0Ea,CAAAA,EAAAA,KAAAA,EAAAA,OAAAA,CAAAA,EAqDrDb,CArDqDa;;;AAA8C;AAOvL;AAAoF;;AACzBb,iBAoDnCuB,oBAAAA,CApDmCvB,MAAAA,EAoDNP,cApDMO,CAAAA,OAAAA,CAAAA,GAoDoBa,MApDpBb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;AAAD;AAW1D;;;;;;;AAAoG;AAW5EoB,iBA0CAI,oBAAAA,CA1CiB,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA;;;;;;AAAuD;AAYhG;;;;;;AAAiH;AAWjH;;;;;AAAqF;AAOrF;;;;AAAqF,iBAoC7DC,uBAAAA,CApC6D,MAAA,EAAA,OAAA,CAAA,EAAA,MAAA,IAoCThC,cApCS,CAAA,MAAA,GAAA,SAAA,CAAA;AAY7D+B,iBAyBAE,aAAAA,CAzBoB,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAyBgBrC,WAzBhB;AAwBpBoC,iBAEAE,aAAAA,CAFuB,GAAA,EAA6BlC,OAAAA,CAAAA,EAAAA,GAAc,IAE9BT,EAAAA,CAAGQ,UAF2B;AAClEkC,iBAEAE,YAAAA,CAFoCvC,GAAAA,EAAAA,OAAW,CAAA,EAAA,GAAA,IAEZL,EAAAA,CAAG6C,SAFS;AACvE;AACA;AAOA;AASA;;;AAAqF7B,iBAT7D8B,kBAAAA,CAS6D9B,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IATpBF,gBASoBE;;;AAAyB;AAU9G;;;;;AAAyHF,iBAVjGiC,wBAUiGjC,CAAAA,UAV9DA,gBAU8DA,CAAAA,CAAAA,MAAAA,EAVpCE,CAUoCF,CAAAA,EAVhCC,qBAUgCD,CAVVE,CAUUF,CAAAA;AAAgB;AAUzI;;;;;AAAwG;AAYxG;;AAAyDA,iBAtBjCkC,sBAsBiClC,CAAAA,UAtBAA,gBAsBAA,CAAAA,CAAAA,MAAAA,EAtB0BE,CAsB1BF,EAAAA,SAAAA,EAtBwCC,qBAsBxCD,CAAAA,EAtBgEA,gBAsBhEA;;;AAAmE;AAY5H;;;;;AAAiI;AAWzGsC,iBAnCAH,uBAmC0B,CAAA,UAnCQnC,gBAmCR,CAAA,CAAA,MAAA,EAnCkCE,CAmClC,CAAA,EAnCsCF,gBAmCtC;;;;;;AAAmE;AAUrH;;;;AAAmH;iBAjC3FoC,iCAAiCpC,0BAA0BE,yBAAyBF;;;;;;;;;;;;iBAYpFqC,sCAAsCrC,0BAA0BE,yBAAyBF;;;;;;;;;;;iBAWzFsC,qCAAqC3C,wBAAwBO,WAAWO,sBAAsBP;;;;;;;;;;iBAU9FqC,8BAAAA,SAAuC5C,sCAAsCA"}
+{"version":3,"file":"zod.d.cts","names":["z3","z4","ZodStringV3","ZodString","ZodStringV4","$ZodType","ZodObjectV3","ZodObject","ZodObjectV4","$ZodObject","ZodDefaultV3","ZodTypeAny","T","ZodDefault","ZodDefaultV4","SomeType","$ZodDefault","ZodOptionalV3","ZodOptional","ZodOptionalV4","$ZodOptional","InteropZodType","Output","ZodTypeDef","Input","ZodType","InteropZodObject","InteropZodDefault","InteropZodObjectShape","InteropZodOptional","Shape","K","InteropZodIssue","ZodIssue","$ZodIssue","InferInteropZodInput","InferInteropZodOutput","Mutable","P","isZodSchemaV4","isZodSchemaV3","isZodSchema","Record","RunOutput","isInteropZodSchema","InteropZodSafeParseResult","SafeParseReturnType","interopSafeParseAsync","Promise","interopParseAsync","interopSafeParse","interopParse","getSchemaDescription","isShapelessZodSchema","isSimpleStringZodSchema","isZodObjectV3","isZodObjectV4","isZodArrayV4","$ZodArray","isInteropZodObject","getInteropZodObjectShape","extendInteropZodObject","interopZodObjectPartial","interopZodObjectStrict","interopZodObjectPassthrough","getInteropZodDefaultGetter","interopZodTransformInputSchema","interopZodObjectMakeFieldsOptional"],"sources":["../../../src/utils/types/zod.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nexport type ZodStringV3 = z3.ZodString;\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\nexport type ZodObjectV4 = z4.$ZodObject;\nexport type ZodDefaultV3<T extends z3.ZodTypeAny> = z3.ZodDefault<T>;\nexport type ZodDefaultV4<T extends z4.SomeType> = z4.$ZodDefault<T>;\nexport type ZodOptionalV3<T extends z3.ZodTypeAny> = z3.ZodOptional<T>;\nexport type ZodOptionalV4<T extends z4.SomeType> = z4.$ZodOptional<T>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\nexport type InteropZodDefault<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodDefaultV3<T> : T extends z4.SomeType ? ZodDefaultV4<T> : never;\nexport type InteropZodOptional<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodOptionalV3<T> : T extends z4.SomeType ? ZodOptionalV4<T> : never;\nexport type InteropZodObjectShape<T extends InteropZodObject = InteropZodObject> = T extends z3.ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : T extends z4.$ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : never;\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<unknown, z3.ZodTypeDef, infer Input> ? Input : T extends z4.$ZodType<unknown, infer Input> ? Input : T extends {\n    _zod: {\n        input: infer Input;\n    };\n} ? Input : never;\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.ZodTypeDef, unknown> ? Output : T extends z4.$ZodType<infer Output, unknown> ? Output : T extends {\n    _zod: {\n        output: infer Output;\n    };\n} ? Output : never;\nexport type Mutable<T> = {\n    -readonly [P in keyof T]: T[P];\n};\nexport declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;\nexport declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;\n/** Backward compatible isZodSchema for Zod 3 */\nexport declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(schema: z3.ZodType<RunOutput> | Record<string, unknown>): schema is z3.ZodType<RunOutput>;\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport declare function isInteropZodSchema(input: unknown): input is InteropZodType;\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<InteropZodSafeParseResult<T>>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<T>;\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParse<T>(schema: InteropZodType<T>, input: unknown): InteropZodSafeParseResult<T>;\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParse<T>(schema: InteropZodType<T>, input: unknown): T;\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport declare function getSchemaDescription(schema: InteropZodType<unknown> | Record<string, unknown>): string | undefined;\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport declare function isShapelessZodSchema(schema: unknown): boolean;\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;\nexport declare function isZodObjectV3(obj: unknown): obj is ZodObjectV3;\nexport declare function isZodObjectV4(obj: unknown): obj is z4.$ZodObject;\nexport declare function isZodArrayV4(obj: unknown): obj is z4.$ZodArray;\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport declare function isInteropZodObject(obj: unknown): obj is InteropZodObject;\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function getInteropZodObjectShape<T extends InteropZodObject>(schema: T): InteropZodObjectShape<T>;\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function extendInteropZodObject<T extends InteropZodObject>(schema: T, extension: InteropZodObjectShape): InteropZodObject;\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectStrict<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport declare function interopZodTransformInputSchema(schema: InteropZodType, recursive?: boolean): InteropZodType;\n/**\n * Creates a modified version of a Zod object schema where fields matching a predicate are made optional.\n * Supports both Zod v3 and v4 schemas and preserves the original schema version.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {(key: string, value: InteropZodType) => boolean} predicate - Function to determine which fields should be optional.\n * @returns {InteropZodObject} The modified Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectMakeFieldsOptional<T extends InteropZodObject>(schema: T, predicate: (key: string, value: InteropZodType) => boolean): InteropZodObject;\nexport {};\n"],"mappings":"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"}

package/dist/utils/types/zod.d.ts

@@ -7,9 +7,15 @@ type ZodStringV4 = z4.$ZodType<string, unknown>;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ZodObjectV3 = z3.ZodObject<any, any, any, any>;
 type ZodObjectV4 = z4.$ZodObject;
+type ZodDefaultV3<T extends z3.ZodTypeAny> = z3.ZodDefault<T>;
+type ZodDefaultV4<T extends z4.SomeType> = z4.$ZodDefault<T>;
+type ZodOptionalV3<T extends z3.ZodTypeAny> = z3.ZodOptional<T>;
+type ZodOptionalV4<T extends z4.SomeType> = z4.$ZodOptional<T>;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;
 type InteropZodObject = ZodObjectV3 | ZodObjectV4;
+type InteropZodDefault<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodDefaultV3<T> : T extends z4.SomeType ? ZodDefaultV4<T> : never;
+type InteropZodOptional<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodOptionalV3<T> : T extends z4.SomeType ? ZodOptionalV4<T> : never;
 type InteropZodObjectShape<T extends InteropZodObject = InteropZodObject> = T extends z3.ZodObject<infer Shape> ? { [K in keyof Shape]: Shape[K] } : T extends z4.$ZodObject<infer Shape> ? { [K in keyof Shape]: Shape[K] } : never;
 type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;
 // Simplified type inference to avoid circular dependencies
@@ -208,6 +214,17 @@ declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T)
  * @returns The input Zod schema of the transform, or undefined if not a transform
  */
 declare function interopZodTransformInputSchema(schema: InteropZodType, recursive?: boolean): InteropZodType;
+/**
+ * Creates a modified version of a Zod object schema where fields matching a predicate are made optional.
+ * Supports both Zod v3 and v4 schemas and preserves the original schema version.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {(key: string, value: InteropZodType) => boolean} predicate - Function to determine which fields should be optional.
+ * @returns {InteropZodObject} The modified Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+declare function interopZodObjectMakeFieldsOptional<T extends InteropZodObject>(schema: T, predicate: (key: string, value: InteropZodType) => boolean): InteropZodObject;
 //#endregion
-export { InferInteropZodInput, InferInteropZodOutput, InteropZodIssue, InteropZodObject, InteropZodObjectShape, InteropZodType, Mutable, ZodObjectV3, ZodObjectV4, ZodStringV3, ZodStringV4, extendInteropZodObject, getInteropZodDefaultGetter, getInteropZodObjectShape, getSchemaDescription, interopParse, interopParseAsync, interopSafeParse, interopSafeParseAsync, interopZodObjectPartial, interopZodObjectPassthrough, interopZodObjectStrict, interopZodTransformInputSchema, isInteropZodObject, isInteropZodSchema, isShapelessZodSchema, isSimpleStringZodSchema, isZodArrayV4, isZodObjectV3, isZodObjectV4, isZodSchema, isZodSchemaV3, isZodSchemaV4 };
+export { InferInteropZodInput, InferInteropZodOutput, InteropZodDefault, InteropZodIssue, InteropZodObject, InteropZodObjectShape, InteropZodOptional, InteropZodType, Mutable, ZodDefaultV3, ZodDefaultV4, ZodObjectV3, ZodObjectV4, ZodOptionalV3, ZodOptionalV4, ZodStringV3, ZodStringV4, extendInteropZodObject, getInteropZodDefaultGetter, getInteropZodObjectShape, getSchemaDescription, interopParse, interopParseAsync, interopSafeParse, interopSafeParseAsync, interopZodObjectMakeFieldsOptional, interopZodObjectPartial, interopZodObjectPassthrough, interopZodObjectStrict, interopZodTransformInputSchema, isInteropZodObject, isInteropZodSchema, isShapelessZodSchema, isSimpleStringZodSchema, isZodArrayV4, isZodObjectV3, isZodObjectV4, isZodSchema, isZodSchemaV3, isZodSchemaV4 };
 //# sourceMappingURL=zod.d.ts.map

package/dist/utils/types/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","names":["z3","z4","ZodStringV3","ZodString","ZodStringV4","$ZodType","ZodObjectV3","ZodObject","ZodObjectV4","$ZodObject","InteropZodType","Output","ZodTypeDef","Input","ZodType","InteropZodObject","InteropZodObjectShape","T","Shape","K","InteropZodIssue","ZodIssue","$ZodIssue","InferInteropZodInput","InferInteropZodOutput","Mutable","P","isZodSchemaV4","isZodSchemaV3","isZodSchema","Record","RunOutput","isInteropZodSchema","InteropZodSafeParseResult","SafeParseReturnType","interopSafeParseAsync","Promise","interopParseAsync","interopSafeParse","interopParse","getSchemaDescription","isShapelessZodSchema","isSimpleStringZodSchema","isZodObjectV3","isZodObjectV4","isZodArrayV4","$ZodArray","isInteropZodObject","getInteropZodObjectShape","extendInteropZodObject","interopZodObjectPartial","interopZodObjectStrict","interopZodObjectPassthrough","getInteropZodDefaultGetter","interopZodTransformInputSchema"],"sources":["../../../src/utils/types/zod.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nexport type ZodStringV3 = z3.ZodString;\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\nexport type ZodObjectV4 = z4.$ZodObject;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\nexport type InteropZodObjectShape<T extends InteropZodObject = InteropZodObject> = T extends z3.ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : T extends z4.$ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : never;\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<unknown, z3.ZodTypeDef, infer Input> ? Input : T extends z4.$ZodType<unknown, infer Input> ? Input : T extends {\n    _zod: {\n        input: infer Input;\n    };\n} ? Input : never;\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.ZodTypeDef, unknown> ? Output : T extends z4.$ZodType<infer Output, unknown> ? Output : T extends {\n    _zod: {\n        output: infer Output;\n    };\n} ? Output : never;\nexport type Mutable<T> = {\n    -readonly [P in keyof T]: T[P];\n};\nexport declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;\nexport declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;\n/** Backward compatible isZodSchema for Zod 3 */\nexport declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(schema: z3.ZodType<RunOutput> | Record<string, unknown>): schema is z3.ZodType<RunOutput>;\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport declare function isInteropZodSchema(input: unknown): input is InteropZodType;\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<InteropZodSafeParseResult<T>>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<T>;\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParse<T>(schema: InteropZodType<T>, input: unknown): InteropZodSafeParseResult<T>;\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParse<T>(schema: InteropZodType<T>, input: unknown): T;\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport declare function getSchemaDescription(schema: InteropZodType<unknown> | Record<string, unknown>): string | undefined;\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport declare function isShapelessZodSchema(schema: unknown): boolean;\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;\nexport declare function isZodObjectV3(obj: unknown): obj is ZodObjectV3;\nexport declare function isZodObjectV4(obj: unknown): obj is z4.$ZodObject;\nexport declare function isZodArrayV4(obj: unknown): obj is z4.$ZodArray;\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport declare function isInteropZodObject(obj: unknown): obj is InteropZodObject;\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function getInteropZodObjectShape<T extends InteropZodObject>(schema: T): InteropZodObjectShape<T>;\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function extendInteropZodObject<T extends InteropZodObject>(schema: T, extension: InteropZodObjectShape): InteropZodObject;\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectStrict<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport declare function interopZodTransformInputSchema(schema: InteropZodType, recursive?: boolean): InteropZodType;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"zod.d.ts","names":["z3","z4","ZodStringV3","ZodString","ZodStringV4","$ZodType","ZodObjectV3","ZodObject","ZodObjectV4","$ZodObject","ZodDefaultV3","ZodTypeAny","T","ZodDefault","ZodDefaultV4","SomeType","$ZodDefault","ZodOptionalV3","ZodOptional","ZodOptionalV4","$ZodOptional","InteropZodType","Output","ZodTypeDef","Input","ZodType","InteropZodObject","InteropZodDefault","InteropZodObjectShape","InteropZodOptional","Shape","K","InteropZodIssue","ZodIssue","$ZodIssue","InferInteropZodInput","InferInteropZodOutput","Mutable","P","isZodSchemaV4","isZodSchemaV3","isZodSchema","Record","RunOutput","isInteropZodSchema","InteropZodSafeParseResult","SafeParseReturnType","interopSafeParseAsync","Promise","interopParseAsync","interopSafeParse","interopParse","getSchemaDescription","isShapelessZodSchema","isSimpleStringZodSchema","isZodObjectV3","isZodObjectV4","isZodArrayV4","$ZodArray","isInteropZodObject","getInteropZodObjectShape","extendInteropZodObject","interopZodObjectPartial","interopZodObjectStrict","interopZodObjectPassthrough","getInteropZodDefaultGetter","interopZodTransformInputSchema","interopZodObjectMakeFieldsOptional"],"sources":["../../../src/utils/types/zod.d.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nexport type ZodStringV3 = z3.ZodString;\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\nexport type ZodObjectV4 = z4.$ZodObject;\nexport type ZodDefaultV3<T extends z3.ZodTypeAny> = z3.ZodDefault<T>;\nexport type ZodDefaultV4<T extends z4.SomeType> = z4.$ZodDefault<T>;\nexport type ZodOptionalV3<T extends z3.ZodTypeAny> = z3.ZodOptional<T>;\nexport type ZodOptionalV4<T extends z4.SomeType> = z4.$ZodOptional<T>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\nexport type InteropZodDefault<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodDefaultV3<T> : T extends z4.SomeType ? ZodDefaultV4<T> : never;\nexport type InteropZodOptional<T = InteropZodObjectShape> = T extends z3.ZodTypeAny ? ZodOptionalV3<T> : T extends z4.SomeType ? ZodOptionalV4<T> : never;\nexport type InteropZodObjectShape<T extends InteropZodObject = InteropZodObject> = T extends z3.ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : T extends z4.$ZodObject<infer Shape> ? {\n    [K in keyof Shape]: Shape[K];\n} : never;\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<unknown, z3.ZodTypeDef, infer Input> ? Input : T extends z4.$ZodType<unknown, infer Input> ? Input : T extends {\n    _zod: {\n        input: infer Input;\n    };\n} ? Input : never;\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.ZodTypeDef, unknown> ? Output : T extends z4.$ZodType<infer Output, unknown> ? Output : T extends {\n    _zod: {\n        output: infer Output;\n    };\n} ? Output : never;\nexport type Mutable<T> = {\n    -readonly [P in keyof T]: T[P];\n};\nexport declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;\nexport declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;\n/** Backward compatible isZodSchema for Zod 3 */\nexport declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(schema: z3.ZodType<RunOutput> | Record<string, unknown>): schema is z3.ZodType<RunOutput>;\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport declare function isInteropZodSchema(input: unknown): input is InteropZodType;\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<InteropZodSafeParseResult<T>>;\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<T>;\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopSafeParse<T>(schema: InteropZodType<T>, input: unknown): InteropZodSafeParseResult<T>;\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport declare function interopParse<T>(schema: InteropZodType<T>, input: unknown): T;\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport declare function getSchemaDescription(schema: InteropZodType<unknown> | Record<string, unknown>): string | undefined;\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport declare function isShapelessZodSchema(schema: unknown): boolean;\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;\nexport declare function isZodObjectV3(obj: unknown): obj is ZodObjectV3;\nexport declare function isZodObjectV4(obj: unknown): obj is z4.$ZodObject;\nexport declare function isZodArrayV4(obj: unknown): obj is z4.$ZodArray;\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport declare function isInteropZodObject(obj: unknown): obj is InteropZodObject;\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function getInteropZodObjectShape<T extends InteropZodObject>(schema: T): InteropZodObjectShape<T>;\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function extendInteropZodObject<T extends InteropZodObject>(schema: T, extension: InteropZodObjectShape): InteropZodObject;\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectStrict<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T, recursive?: boolean): InteropZodObject;\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport declare function interopZodTransformInputSchema(schema: InteropZodType, recursive?: boolean): InteropZodType;\n/**\n * Creates a modified version of a Zod object schema where fields matching a predicate are made optional.\n * Supports both Zod v3 and v4 schemas and preserves the original schema version.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {(key: string, value: InteropZodType) => boolean} predicate - Function to determine which fields should be optional.\n * @returns {InteropZodObject} The modified Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport declare function interopZodObjectMakeFieldsOptional<T extends InteropZodObject>(schema: T, predicate: (key: string, value: InteropZodType) => boolean): InteropZodObject;\nexport {};\n"],"mappings":"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"}

package/dist/utils/types/zod.js

@@ -56,7 +56,7 @@ async function interopSafeParseAsync(schema, input) {
 			error
 		};
 	}
-	if (isZodSchemaV3(schema)) return schema.safeParse(input);
+	if (isZodSchemaV3(schema)) return await schema.safeParseAsync(input);
 	throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
 }
 /**
@@ -70,8 +70,8 @@ async function interopSafeParseAsync(schema, input) {
 * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.
 */
 async function interopParseAsync(schema, input) {
-	if (isZodSchemaV4(schema)) return parse(schema, input);
-	if (isZodSchemaV3(schema)) return schema.parse(input);
+	if (isZodSchemaV4(schema)) return await parseAsync(schema, input);
+	if (isZodSchemaV3(schema)) return await schema.parseAsync(input);
 	throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
 }
 /**
@@ -413,7 +413,42 @@ function interopZodTransformInputSchema(schema, recursive = false) {
 	}
 	throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
 }
+/**
+* Creates a modified version of a Zod object schema where fields matching a predicate are made optional.
+* Supports both Zod v3 and v4 schemas and preserves the original schema version.
+*
+* @template T - The type of the Zod object schema.
+* @param {T} schema - The Zod object schema instance (either v3 or v4).
+* @param {(key: string, value: InteropZodType) => boolean} predicate - Function to determine which fields should be optional.
+* @returns {InteropZodObject} The modified Zod object schema.
+* @throws {Error} If the schema is not a Zod v3 or v4 object.
+*/
+function interopZodObjectMakeFieldsOptional(schema, predicate) {
+	if (isZodSchemaV3(schema)) {
+		const shape = getInteropZodObjectShape(schema);
+		const modifiedShape = {};
+		for (const [key, value] of Object.entries(shape)) if (predicate(key, value)) modifiedShape[key] = value.optional();
+		else modifiedShape[key] = value;
+		return schema.extend(modifiedShape);
+	}
+	if (isZodSchemaV4(schema)) {
+		const shape = getInteropZodObjectShape(schema);
+		const outputShape = { ...schema._zod.def.shape };
+		for (const [key, value] of Object.entries(shape)) if (predicate(key, value)) outputShape[key] = new $ZodOptional({
+			type: "optional",
+			innerType: value
+		});
+		const modifiedSchema = clone(schema, {
+			...schema._zod.def,
+			shape: outputShape
+		});
+		const meta = globalRegistry.get(schema);
+		if (meta) globalRegistry.add(modifiedSchema, meta);
+		return modifiedSchema;
+	}
+	throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
 
 //#endregion
-export { extendInteropZodObject, getInteropZodDefaultGetter, getInteropZodObjectShape, getSchemaDescription, interopParse, interopParseAsync, interopSafeParse, interopSafeParseAsync, interopZodObjectPartial, interopZodObjectPassthrough, interopZodObjectStrict, interopZodTransformInputSchema, isInteropZodObject, isInteropZodSchema, isShapelessZodSchema, isSimpleStringZodSchema, isZodArrayV4, isZodObjectV3, isZodObjectV4, isZodSchema, isZodSchemaV3, isZodSchemaV4 };
+export { extendInteropZodObject, getInteropZodDefaultGetter, getInteropZodObjectShape, getSchemaDescription, interopParse, interopParseAsync, interopSafeParse, interopSafeParseAsync, interopZodObjectMakeFieldsOptional, interopZodObjectPartial, interopZodObjectPassthrough, interopZodObjectStrict, interopZodTransformInputSchema, isInteropZodObject, isInteropZodSchema, isShapelessZodSchema, isSimpleStringZodSchema, isZodArrayV4, isZodObjectV3, isZodObjectV4, isZodSchema, isZodSchemaV3, isZodSchemaV4 };
 //# sourceMappingURL=zod.js.map

package/dist/utils/types/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","names":["schema: unknown","schema: z3.ZodType<RunOutput> | Record<string, unknown>","input: unknown","schema: InteropZodType<T>","schema: InteropZodType<unknown> | Record<string, unknown>","obj: unknown","schema: T","extension: InteropZodObjectShape","outputShape: Mutable<z4.$ZodShape>","meta","schema: InteropZodType","outputSchema: InteropZodType"],"sources":["../../../src/utils/types/zod.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport {\n  parse,\n  parseAsync,\n  globalRegistry,\n  util,\n  clone,\n  _unknown,\n  _never,\n  $ZodUnknown,\n  $ZodNever,\n  $ZodOptional,\n} from \"zod/v4/core\";\n\nexport type ZodStringV3 = z3.ZodString;\n\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\n\nexport type ZodObjectV4 = z4.$ZodObject;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> =\n  | z3.ZodType<Output, z3.ZodTypeDef, Input>\n  | z4.$ZodType<Output, Input>;\n\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\n\nexport type InteropZodObjectShape<\n  T extends InteropZodObject = InteropZodObject\n> = T extends z3.ZodObject<infer Shape>\n  ? { [K in keyof Shape]: Shape[K] }\n  : T extends z4.$ZodObject<infer Shape>\n  ? { [K in keyof Shape]: Shape[K] }\n  : never;\n\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<\n  unknown,\n  z3.ZodTypeDef,\n  infer Input\n>\n  ? Input\n  : T extends z4.$ZodType<unknown, infer Input>\n  ? Input\n  : T extends { _zod: { input: infer Input } }\n  ? Input\n  : never;\n\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<\n  infer Output,\n  z3.ZodTypeDef,\n  unknown\n>\n  ? Output\n  : T extends z4.$ZodType<infer Output, unknown>\n  ? Output\n  : T extends { _zod: { output: infer Output } }\n  ? Output\n  : never;\n\nexport type Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\nexport function isZodSchemaV4(\n  schema: unknown\n): schema is z4.$ZodType<unknown, unknown> {\n  if (typeof schema !== \"object\" || schema === null) {\n    return false;\n  }\n\n  const obj = schema as Record<string, unknown>;\n  if (!(\"_zod\" in obj)) {\n    return false;\n  }\n\n  const zod = obj._zod;\n  return (\n    typeof zod === \"object\" &&\n    zod !== null &&\n    \"def\" in (zod as Record<string, unknown>)\n  );\n}\n\nexport function isZodSchemaV3(\n  schema: unknown\n): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown> {\n  if (typeof schema !== \"object\" || schema === null) {\n    return false;\n  }\n\n  const obj = schema as Record<string, unknown>;\n  if (!(\"_def\" in obj) || \"_zod\" in obj) {\n    return false;\n  }\n\n  const def = obj._def;\n  return (\n    typeof def === \"object\" &&\n    def != null &&\n    \"typeName\" in (def as Record<string, unknown>)\n  );\n}\n\n/** Backward compatible isZodSchema for Zod 3 */\nexport function isZodSchema<\n  RunOutput extends Record<string, unknown> = Record<string, unknown>\n>(\n  schema: z3.ZodType<RunOutput> | Record<string, unknown>\n): schema is z3.ZodType<RunOutput> {\n  if (isZodSchemaV4(schema)) {\n    console.warn(\n      \"[WARNING] Attempting to use Zod 4 schema in a context where Zod 3 schema is expected. This may cause unexpected behavior.\"\n    );\n  }\n  return isZodSchemaV3(schema);\n}\n\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport function isInteropZodSchema(input: unknown): input is InteropZodType {\n  if (!input) {\n    return false;\n  }\n  if (typeof input !== \"object\") {\n    return false;\n  }\n  if (Array.isArray(input)) {\n    return false;\n  }\n  if (\n    isZodSchemaV4(input) ||\n    isZodSchemaV3(input as z3.ZodType<Record<string, unknown>>)\n  ) {\n    return true;\n  }\n  return false;\n}\n\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport async function interopSafeParseAsync<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): Promise<InteropZodSafeParseResult<T>> {\n  if (isZodSchemaV4(schema)) {\n    try {\n      const data = await parseAsync(schema, input);\n      return {\n        success: true,\n        data,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        error: error as z3.ZodError<T>,\n      };\n    }\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.safeParse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport async function interopParseAsync<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): Promise<T> {\n  if (isZodSchemaV4(schema)) {\n    return parse(schema, input);\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.parse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport function interopSafeParse<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): InteropZodSafeParseResult<T> {\n  if (isZodSchemaV4(schema)) {\n    try {\n      const data = parse(schema, input);\n      return {\n        success: true,\n        data,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        error: error as z3.ZodError<T>,\n      };\n    }\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.safeParse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport function interopParse<T>(schema: InteropZodType<T>, input: unknown): T {\n  if (isZodSchemaV4(schema)) {\n    return parse(schema, input);\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.parse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport function getSchemaDescription(\n  schema: InteropZodType<unknown> | Record<string, unknown>\n): string | undefined {\n  if (isZodSchemaV4(schema)) {\n    return globalRegistry.get(schema)?.description;\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.description as string | undefined;\n  }\n  if (\"description\" in schema && typeof schema.description === \"string\") {\n    return schema.description;\n  }\n  return undefined;\n}\n\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport function isShapelessZodSchema(schema: unknown): boolean {\n  if (!isInteropZodSchema(schema)) {\n    return false;\n  }\n\n  // Check for v3 schemas\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    // @ts-expect-error - zod v3 types are not compatible with zod v4 types\n    const def = schema._def as { typeName?: string };\n\n    // ZodObject is only shaped if it has actual shape keys\n    if (def.typeName === \"ZodObject\") {\n      const obj = schema as { shape?: Record<string, unknown> };\n      return !obj.shape || Object.keys(obj.shape).length === 0;\n    }\n\n    // ZodRecord is shapeless (dynamic key-value mapping)\n    if (def.typeName === \"ZodRecord\") {\n      return true;\n    }\n  }\n\n  // Check for v4 schemas\n  if (isZodSchemaV4(schema)) {\n    const def = schema._zod.def;\n\n    // Object type is only shaped if it has actual shape keys\n    if (def.type === \"object\") {\n      const obj = schema as { shape?: Record<string, unknown> };\n      return !obj.shape || Object.keys(obj.shape).length === 0;\n    }\n\n    // Record type is shapeless (dynamic key-value mapping)\n    if (def.type === \"record\") {\n      return true;\n    }\n  }\n\n  // For other schemas, check if they have a `shape` property\n  // If they don't have shape, they're likely shapeless\n  if (typeof schema === \"object\" && schema !== null && !(\"shape\" in schema)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport function isSimpleStringZodSchema(\n  schema: unknown\n): schema is InteropZodType<string | undefined> {\n  if (!isInteropZodSchema(schema)) {\n    return false;\n  }\n\n  // For v3 schemas\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    // @ts-expect-error - zod v3 types are not compatible with zod v4 types\n    const def = schema._def as { typeName?: string };\n\n    // Only accept basic ZodString\n    return def.typeName === \"ZodString\";\n  }\n\n  // For v4 schemas\n  if (isZodSchemaV4(schema)) {\n    const def = schema._zod.def;\n\n    // Only accept basic string type\n    return def.type === \"string\";\n  }\n\n  return false;\n}\n\nexport function isZodObjectV3(obj: unknown): obj is ZodObjectV3 {\n  // Zod v3 object schemas have _def.typeName === \"ZodObject\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_def\" in obj &&\n    typeof obj._def === \"object\" &&\n    obj._def !== null &&\n    \"typeName\" in obj._def &&\n    obj._def.typeName === \"ZodObject\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function isZodObjectV4(obj: unknown): obj is z4.$ZodObject {\n  if (!isZodSchemaV4(obj)) return false;\n  // Zod v4 object schemas have _zod.def.type === \"object\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_zod\" in obj &&\n    typeof obj._zod === \"object\" &&\n    obj._zod !== null &&\n    \"def\" in obj._zod &&\n    typeof obj._zod.def === \"object\" &&\n    obj._zod.def !== null &&\n    \"type\" in obj._zod.def &&\n    obj._zod.def.type === \"object\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function isZodArrayV4(obj: unknown): obj is z4.$ZodArray {\n  if (!isZodSchemaV4(obj)) return false;\n  // Zod v4 array schemas have _zod.def.type === \"array\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_zod\" in obj &&\n    typeof obj._zod === \"object\" &&\n    obj._zod !== null &&\n    \"def\" in obj._zod &&\n    typeof obj._zod.def === \"object\" &&\n    obj._zod.def !== null &&\n    \"type\" in obj._zod.def &&\n    obj._zod.def.type === \"array\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport function isInteropZodObject(obj: unknown): obj is InteropZodObject {\n  if (isZodObjectV3(obj)) return true;\n  if (isZodObjectV4(obj)) return true;\n  return false;\n}\n\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function getInteropZodObjectShape<T extends InteropZodObject>(\n  schema: T\n): InteropZodObjectShape<T> {\n  if (isZodSchemaV3(schema)) {\n    return schema.shape;\n  }\n  if (isZodSchemaV4(schema)) {\n    return schema._zod.def.shape as InteropZodObjectShape<T>;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function extendInteropZodObject<T extends InteropZodObject>(\n  schema: T,\n  extension: InteropZodObjectShape\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    return schema.extend(extension as z3.ZodRawShape);\n  }\n  if (isZodSchemaV4(schema)) {\n    return util.extend(schema, extension);\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectPartial<T extends InteropZodObject>(\n  schema: T\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    // z3: .partial() exists and works as expected\n    return schema.partial();\n  }\n  if (isZodSchemaV4(schema)) {\n    // z4: util.partial exists and works as expected\n    return util.partial($ZodOptional, schema, undefined);\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectStrict<T extends InteropZodObject>(\n  schema: T,\n  recursive = false\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema.strict();\n  }\n  if (isZodObjectV4(schema)) {\n    const outputShape: Mutable<z4.$ZodShape> = schema._zod.def.shape;\n    if (recursive) {\n      for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {\n        // If the shape key is a v4 object schema, we need to make it strict\n        if (isZodObjectV4(keySchema)) {\n          const outputSchema = interopZodObjectStrict(keySchema, recursive);\n          outputShape[key] = outputSchema as ZodObjectV4;\n        }\n        // If the shape key is a v4 array schema, we need to make the element\n        // schema strict if it's an object schema\n        else if (isZodArrayV4(keySchema)) {\n          let elementSchema = keySchema._zod.def.element;\n          if (isZodObjectV4(elementSchema)) {\n            elementSchema = interopZodObjectStrict(\n              elementSchema,\n              recursive\n            ) as ZodObjectV4;\n          }\n          outputShape[key] = clone(keySchema, {\n            ...keySchema._zod.def,\n            element: elementSchema,\n          });\n        }\n        // Otherwise, just use the keySchema\n        else {\n          outputShape[key] = keySchema;\n        }\n        // Assign meta fields to the keySchema\n        const meta = globalRegistry.get(keySchema);\n        if (meta) globalRegistry.add(outputShape[key], meta);\n      }\n    }\n    const modifiedSchema = clone<ZodObjectV4>(schema, {\n      ...schema._zod.def,\n      shape: outputShape,\n      catchall: _never($ZodNever),\n    });\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(modifiedSchema, meta);\n    return modifiedSchema;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectPassthrough<T extends InteropZodObject>(\n  schema: T,\n  recursive = false\n): InteropZodObject {\n  if (isZodObjectV3(schema)) {\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema.passthrough();\n  }\n  if (isZodObjectV4(schema)) {\n    const outputShape: Mutable<z4.$ZodShape> = schema._zod.def.shape;\n    if (recursive) {\n      for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {\n        // If the shape key is a v4 object schema, we need to make it passthrough\n        if (isZodObjectV4(keySchema)) {\n          const outputSchema = interopZodObjectPassthrough(\n            keySchema,\n            recursive\n          );\n          outputShape[key] = outputSchema as ZodObjectV4;\n        }\n        // If the shape key is a v4 array schema, we need to make the element\n        // schema passthrough if it's an object schema\n        else if (isZodArrayV4(keySchema)) {\n          let elementSchema = keySchema._zod.def.element;\n          if (isZodObjectV4(elementSchema)) {\n            elementSchema = interopZodObjectPassthrough(\n              elementSchema,\n              recursive\n            ) as ZodObjectV4;\n          }\n          outputShape[key] = clone(keySchema, {\n            ...keySchema._zod.def,\n            element: elementSchema,\n          });\n        }\n        // Otherwise, just use the keySchema\n        else {\n          outputShape[key] = keySchema;\n        }\n        // Assign meta fields to the keySchema\n        const meta = globalRegistry.get(keySchema);\n        if (meta) globalRegistry.add(outputShape[key], meta);\n      }\n    }\n    const modifiedSchema = clone<ZodObjectV4>(schema, {\n      ...schema._zod.def,\n      shape: outputShape,\n      catchall: _unknown($ZodUnknown),\n    });\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(modifiedSchema, meta);\n    return modifiedSchema;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport function getInteropZodDefaultGetter<T extends InteropZodType>(\n  schema: T\n): (() => InferInteropZodOutput<T>) | undefined {\n  if (isZodSchemaV3(schema)) {\n    try {\n      const defaultValue = schema.parse(undefined);\n      return () => defaultValue as InferInteropZodOutput<T>;\n    } catch {\n      return undefined;\n    }\n  }\n  if (isZodSchemaV4(schema)) {\n    try {\n      const defaultValue = parse(schema, undefined);\n      return () => defaultValue as InferInteropZodOutput<T>;\n    } catch {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nfunction isZodTransformV3(\n  schema: InteropZodType\n): schema is z3.ZodEffects<z3.ZodTypeAny> {\n  return (\n    isZodSchemaV3(schema) &&\n    \"typeName\" in schema._def &&\n    schema._def.typeName === \"ZodEffects\"\n  );\n}\n\nfunction isZodTransformV4(schema: InteropZodType): schema is z4.$ZodPipe {\n  return isZodSchemaV4(schema) && schema._zod.def.type === \"pipe\";\n}\n\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport function interopZodTransformInputSchema(\n  schema: InteropZodType,\n  recursive = false\n): InteropZodType {\n  // Zod v3: ._def.schema is the input schema for ZodEffects (transform)\n  if (isZodSchemaV3(schema)) {\n    if (isZodTransformV3(schema)) {\n      return interopZodTransformInputSchema(schema._def.schema, recursive);\n    }\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema;\n  }\n\n  // Zod v4: _def.type is the input schema for ZodEffects (transform)\n  if (isZodSchemaV4(schema)) {\n    let outputSchema: InteropZodType = schema;\n    if (isZodTransformV4(schema)) {\n      outputSchema = interopZodTransformInputSchema(\n        schema._zod.def.in,\n        recursive\n      );\n    }\n    if (recursive) {\n      // Handle nested object schemas\n      if (isZodObjectV4(outputSchema)) {\n        const outputShape: Mutable<z4.$ZodShape> = outputSchema._zod.def.shape;\n        for (const [key, keySchema] of Object.entries(\n          outputSchema._zod.def.shape\n        )) {\n          outputShape[key] = interopZodTransformInputSchema(\n            keySchema,\n            recursive\n          ) as z4.$ZodType;\n        }\n        outputSchema = clone<ZodObjectV4>(outputSchema, {\n          ...outputSchema._zod.def,\n          shape: outputShape,\n        });\n      }\n      // Handle nested array schemas\n      else if (isZodArrayV4(outputSchema)) {\n        const elementSchema = interopZodTransformInputSchema(\n          outputSchema._zod.def.element,\n          recursive\n        );\n        outputSchema = clone<z4.$ZodArray>(outputSchema, {\n          ...outputSchema._zod.def,\n          element: elementSchema as z4.$ZodType,\n        });\n      }\n    }\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(outputSchema as z4.$ZodType, meta);\n    return outputSchema;\n  }\n\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n"],"mappings":";;;AAsEA,SAAgB,cACdA,QACyC;AACzC,KAAI,OAAO,WAAW,YAAY,WAAW,KAC3C,QAAO;CAGT,MAAM,MAAM;AACZ,KAAI,EAAE,UAAU,KACd,QAAO;CAGT,MAAM,MAAM,IAAI;AAChB,QACE,OAAO,QAAQ,YACf,QAAQ,QACR,SAAU;AAEb;AAED,SAAgB,cACdA,QACuD;AACvD,KAAI,OAAO,WAAW,YAAY,WAAW,KAC3C,QAAO;CAGT,MAAM,MAAM;AACZ,KAAI,EAAE,UAAU,QAAQ,UAAU,IAChC,QAAO;CAGT,MAAM,MAAM,IAAI;AAChB,QACE,OAAO,QAAQ,YACf,OAAO,QACP,cAAe;AAElB;;AAGD,SAAgB,YAGdC,QACiC;AACjC,KAAI,cAAc,OAAO,EACvB,QAAQ,KACN,4HACD;AAEH,QAAO,cAAc,OAAO;AAC7B;;;;;;;AAQD,SAAgB,mBAAmBC,OAAyC;AAC1E,KAAI,CAAC,MACH,QAAO;AAET,KAAI,OAAO,UAAU,SACnB,QAAO;AAET,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO;AAET,KACE,cAAc,MAAM,IACpB,cAAc,MAA6C,CAE3D,QAAO;AAET,QAAO;AACR;;;;;;;;;;;AAcD,eAAsB,sBACpBC,QACAD,OACuC;AACvC,KAAI,cAAc,OAAO,CACvB,KAAI;EACF,MAAM,OAAO,MAAM,WAAW,QAAQ,MAAM;AAC5C,SAAO;GACL,SAAS;GACT;EACD;CACF,SAAQ,OAAO;AACd,SAAO;GACL,SAAS;GACF;EACR;CACF;AAEH,KAAI,cAAc,OAA8C,CAC9D,QAAO,OAAO,UAAU,MAAM;AAEhC,OAAM,IAAI,MAAM;AACjB;;;;;;;;;;;AAYD,eAAsB,kBACpBC,QACAD,OACY;AACZ,KAAI,cAAc,OAAO,CACvB,QAAO,MAAM,QAAQ,MAAM;AAE7B,KAAI,cAAc,OAA8C,CAC9D,QAAO,OAAO,MAAM,MAAM;AAE5B,OAAM,IAAI,MAAM;AACjB;;;;;;;;;;;;AAaD,SAAgB,iBACdC,QACAD,OAC8B;AAC9B,KAAI,cAAc,OAAO,CACvB,KAAI;EACF,MAAM,OAAO,MAAM,QAAQ,MAAM;AACjC,SAAO;GACL,SAAS;GACT;EACD;CACF,SAAQ,OAAO;AACd,SAAO;GACL,SAAS;GACF;EACR;CACF;AAEH,KAAI,cAAc,OAA8C,CAC9D,QAAO,OAAO,UAAU,MAAM;AAEhC,OAAM,IAAI,MAAM;AACjB;;;;;;;;;;;AAYD,SAAgB,aAAgBC,QAA2BD,OAAmB;AAC5E,KAAI,cAAc,OAAO,CACvB,QAAO,MAAM,QAAQ,MAAM;AAE7B,KAAI,cAAc,OAA8C,CAC9D,QAAO,OAAO,MAAM,MAAM;AAE5B,OAAM,IAAI,MAAM;AACjB;;;;;;;AAQD,SAAgB,qBACdE,QACoB;AACpB,KAAI,cAAc,OAAO,CACvB,QAAO,eAAe,IAAI,OAAO,EAAE;AAErC,KAAI,cAAc,OAA8C,CAC9D,QAAO,OAAO;AAEhB,KAAI,iBAAiB,UAAU,OAAO,OAAO,gBAAgB,SAC3D,QAAO,OAAO;AAEhB,QAAO;AACR;;;;;;;;;;;;AAaD,SAAgB,qBAAqBJ,QAA0B;AAC7D,KAAI,CAAC,mBAAmB,OAAO,CAC7B,QAAO;AAIT,KAAI,cAAc,OAA8C,EAAE;EAEhE,MAAM,MAAM,OAAO;AAGnB,MAAI,IAAI,aAAa,aAAa;GAChC,MAAM,MAAM;AACZ,UAAO,CAAC,IAAI,SAAS,OAAO,KAAK,IAAI,MAAM,CAAC,WAAW;EACxD;AAGD,MAAI,IAAI,aAAa,YACnB,QAAO;CAEV;AAGD,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,MAAM,OAAO,KAAK;AAGxB,MAAI,IAAI,SAAS,UAAU;GACzB,MAAM,MAAM;AACZ,UAAO,CAAC,IAAI,SAAS,OAAO,KAAK,IAAI,MAAM,CAAC,WAAW;EACxD;AAGD,MAAI,IAAI,SAAS,SACf,QAAO;CAEV;AAID,KAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,EAAE,WAAW,QAChE,QAAO;AAGT,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,SAAgB,wBACdA,QAC8C;AAC9C,KAAI,CAAC,mBAAmB,OAAO,CAC7B,QAAO;AAIT,KAAI,cAAc,OAA8C,EAAE;EAEhE,MAAM,MAAM,OAAO;AAGnB,SAAO,IAAI,aAAa;CACzB;AAGD,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,MAAM,OAAO,KAAK;AAGxB,SAAO,IAAI,SAAS;CACrB;AAED,QAAO;AACR;AAED,SAAgB,cAAcK,KAAkC;AAE9D,KACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,OAAO,IAAI,SAAS,YACpB,IAAI,SAAS,QACb,cAAc,IAAI,QAClB,IAAI,KAAK,aAAa,YAEtB,QAAO;AAET,QAAO;AACR;AAED,SAAgB,cAAcA,KAAoC;AAChE,KAAI,CAAC,cAAc,IAAI,CAAE,QAAO;AAEhC,KACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,OAAO,IAAI,SAAS,YACpB,IAAI,SAAS,QACb,SAAS,IAAI,QACb,OAAO,IAAI,KAAK,QAAQ,YACxB,IAAI,KAAK,QAAQ,QACjB,UAAU,IAAI,KAAK,OACnB,IAAI,KAAK,IAAI,SAAS,SAEtB,QAAO;AAET,QAAO;AACR;AAED,SAAgB,aAAaA,KAAmC;AAC9D,KAAI,CAAC,cAAc,IAAI,CAAE,QAAO;AAEhC,KACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,OAAO,IAAI,SAAS,YACpB,IAAI,SAAS,QACb,SAAS,IAAI,QACb,OAAO,IAAI,KAAK,QAAQ,YACxB,IAAI,KAAK,QAAQ,QACjB,UAAU,IAAI,KAAK,OACnB,IAAI,KAAK,IAAI,SAAS,QAEtB,QAAO;AAET,QAAO;AACR;;;;;;;AAQD,SAAgB,mBAAmBA,KAAuC;AACxE,KAAI,cAAc,IAAI,CAAE,QAAO;AAC/B,KAAI,cAAc,IAAI,CAAE,QAAO;AAC/B,QAAO;AACR;;;;;;;;;AAUD,SAAgB,yBACdC,QAC0B;AAC1B,KAAI,cAAc,OAAO,CACvB,QAAO,OAAO;AAEhB,KAAI,cAAc,OAAO,CACvB,QAAO,OAAO,KAAK,IAAI;AAEzB,OAAM,IAAI,MACR;AAEH;;;;;;;;;;AAWD,SAAgB,uBACdA,QACAC,WACkB;AAClB,KAAI,cAAc,OAAO,CACvB,QAAO,OAAO,OAAO,UAA4B;AAEnD,KAAI,cAAc,OAAO,CACvB,QAAO,KAAK,OAAO,QAAQ,UAAU;AAEvC,OAAM,IAAI,MACR;AAEH;;;;;;;;;;AAWD,SAAgB,wBACdD,QACkB;AAClB,KAAI,cAAc,OAAO,CAEvB,QAAO,OAAO,SAAS;AAEzB,KAAI,cAAc,OAAO,CAEvB,QAAO,KAAK,QAAQ,cAAc,QAAQ,OAAU;AAEtD,OAAM,IAAI,MACR;AAEH;;;;;;;;;;;;AAaD,SAAgB,uBACdA,QACA,YAAY,OACM;AAClB,KAAI,cAAc,OAAO,CAGvB,QAAO,OAAO,QAAQ;AAExB,KAAI,cAAc,OAAO,EAAE;EACzB,MAAME,cAAqC,OAAO,KAAK,IAAI;AAC3D,MAAI,UACF,MAAK,MAAM,CAAC,KAAK,UAAU,IAAI,OAAO,QAAQ,OAAO,KAAK,IAAI,MAAM,EAAE;AAEpE,OAAI,cAAc,UAAU,EAAE;IAC5B,MAAM,eAAe,uBAAuB,WAAW,UAAU;IACjE,YAAY,OAAO;GACpB,WAGQ,aAAa,UAAU,EAAE;IAChC,IAAI,gBAAgB,UAAU,KAAK,IAAI;AACvC,QAAI,cAAc,cAAc,EAC9B,gBAAgB,uBACd,eACA,UACD;IAEH,YAAY,OAAO,MAAM,WAAW;KAClC,GAAG,UAAU,KAAK;KAClB,SAAS;IACV,EAAC;GACH,OAGC,YAAY,OAAO;GAGrB,MAAMC,SAAO,eAAe,IAAI,UAAU;AAC1C,OAAIA,QAAM,eAAe,IAAI,YAAY,MAAMA,OAAK;EACrD;EAEH,MAAM,iBAAiB,MAAmB,QAAQ;GAChD,GAAG,OAAO,KAAK;GACf,OAAO;GACP,UAAU,OAAO,UAAU;EAC5B,EAAC;EACF,MAAM,OAAO,eAAe,IAAI,OAAO;AACvC,MAAI,MAAM,eAAe,IAAI,gBAAgB,KAAK;AAClD,SAAO;CACR;AACD,OAAM,IAAI,MACR;AAEH;;;;;;;;;;;;AAaD,SAAgB,4BACdH,QACA,YAAY,OACM;AAClB,KAAI,cAAc,OAAO,CAGvB,QAAO,OAAO,aAAa;AAE7B,KAAI,cAAc,OAAO,EAAE;EACzB,MAAME,cAAqC,OAAO,KAAK,IAAI;AAC3D,MAAI,UACF,MAAK,MAAM,CAAC,KAAK,UAAU,IAAI,OAAO,QAAQ,OAAO,KAAK,IAAI,MAAM,EAAE;AAEpE,OAAI,cAAc,UAAU,EAAE;IAC5B,MAAM,eAAe,4BACnB,WACA,UACD;IACD,YAAY,OAAO;GACpB,WAGQ,aAAa,UAAU,EAAE;IAChC,IAAI,gBAAgB,UAAU,KAAK,IAAI;AACvC,QAAI,cAAc,cAAc,EAC9B,gBAAgB,4BACd,eACA,UACD;IAEH,YAAY,OAAO,MAAM,WAAW;KAClC,GAAG,UAAU,KAAK;KAClB,SAAS;IACV,EAAC;GACH,OAGC,YAAY,OAAO;GAGrB,MAAMC,SAAO,eAAe,IAAI,UAAU;AAC1C,OAAIA,QAAM,eAAe,IAAI,YAAY,MAAMA,OAAK;EACrD;EAEH,MAAM,iBAAiB,MAAmB,QAAQ;GAChD,GAAG,OAAO,KAAK;GACf,OAAO;GACP,UAAU,SAAS,YAAY;EAChC,EAAC;EACF,MAAM,OAAO,eAAe,IAAI,OAAO;AACvC,MAAI,MAAM,eAAe,IAAI,gBAAgB,KAAK;AAClD,SAAO;CACR;AACD,OAAM,IAAI,MACR;AAEH;;;;;;;;;;;AAYD,SAAgB,2BACdH,QAC8C;AAC9C,KAAI,cAAc,OAAO,CACvB,KAAI;EACF,MAAM,eAAe,OAAO,MAAM,OAAU;AAC5C,SAAO,MAAM;CACd,QAAO;AACN,SAAO;CACR;AAEH,KAAI,cAAc,OAAO,CACvB,KAAI;EACF,MAAM,eAAe,MAAM,QAAQ,OAAU;AAC7C,SAAO,MAAM;CACd,QAAO;AACN,SAAO;CACR;AAEH,QAAO;AACR;AAED,SAAS,iBACPI,QACwC;AACxC,QACE,cAAc,OAAO,IACrB,cAAc,OAAO,QACrB,OAAO,KAAK,aAAa;AAE5B;AAED,SAAS,iBAAiBA,QAA+C;AACvE,QAAO,cAAc,OAAO,IAAI,OAAO,KAAK,IAAI,SAAS;AAC1D;;;;;;;;;;AAWD,SAAgB,+BACdA,QACA,YAAY,OACI;AAEhB,KAAI,cAAc,OAAO,EAAE;AACzB,MAAI,iBAAiB,OAAO,CAC1B,QAAO,+BAA+B,OAAO,KAAK,QAAQ,UAAU;AAItE,SAAO;CACR;AAGD,KAAI,cAAc,OAAO,EAAE;EACzB,IAAIC,eAA+B;AACnC,MAAI,iBAAiB,OAAO,EAC1B,eAAe,+BACb,OAAO,KAAK,IAAI,IAChB,UACD;AAEH,MAAI,WAEF;OAAI,cAAc,aAAa,EAAE;IAC/B,MAAMH,cAAqC,aAAa,KAAK,IAAI;AACjE,SAAK,MAAM,CAAC,KAAK,UAAU,IAAI,OAAO,QACpC,aAAa,KAAK,IAAI,MACvB,EACC,YAAY,OAAO,+BACjB,WACA,UACD;IAEH,eAAe,MAAmB,cAAc;KAC9C,GAAG,aAAa,KAAK;KACrB,OAAO;IACR,EAAC;GACH,WAEQ,aAAa,aAAa,EAAE;IACnC,MAAM,gBAAgB,+BACpB,aAAa,KAAK,IAAI,SACtB,UACD;IACD,eAAe,MAAoB,cAAc;KAC/C,GAAG,aAAa,KAAK;KACrB,SAAS;IACV,EAAC;GACH;;EAEH,MAAM,OAAO,eAAe,IAAI,OAAO;AACvC,MAAI,MAAM,eAAe,IAAI,cAA6B,KAAK;AAC/D,SAAO;CACR;AAED,OAAM,IAAI,MAAM;AACjB"}
+{"version":3,"file":"zod.js","names":["schema: unknown","schema: z3.ZodType<RunOutput> | Record<string, unknown>","input: unknown","schema: InteropZodType<T>","schema: InteropZodType<unknown> | Record<string, unknown>","obj: unknown","schema: T","extension: InteropZodObjectShape","outputShape: Mutable<z4.$ZodShape>","meta","schema: InteropZodType","outputSchema: InteropZodType","predicate: (key: string, value: InteropZodType) => boolean","modifiedShape: Record<string, z3.ZodTypeAny>"],"sources":["../../../src/utils/types/zod.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport {\n  parse,\n  parseAsync,\n  globalRegistry,\n  util,\n  clone,\n  _unknown,\n  _never,\n  $ZodUnknown,\n  $ZodNever,\n  $ZodOptional,\n} from \"zod/v4/core\";\n\nexport type ZodStringV3 = z3.ZodString;\n\nexport type ZodStringV4 = z4.$ZodType<string, unknown>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ZodObjectV3 = z3.ZodObject<any, any, any, any>;\n\nexport type ZodObjectV4 = z4.$ZodObject;\n\nexport type ZodDefaultV3<T extends z3.ZodTypeAny> = z3.ZodDefault<T>;\nexport type ZodDefaultV4<T extends z4.SomeType> = z4.$ZodDefault<T>;\nexport type ZodOptionalV3<T extends z3.ZodTypeAny> = z3.ZodOptional<T>;\nexport type ZodOptionalV4<T extends z4.SomeType> = z4.$ZodOptional<T>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InteropZodType<Output = any, Input = Output> =\n  | z3.ZodType<Output, z3.ZodTypeDef, Input>\n  | z4.$ZodType<Output, Input>;\n\nexport type InteropZodObject = ZodObjectV3 | ZodObjectV4;\nexport type InteropZodDefault<T = InteropZodObjectShape> =\n  T extends z3.ZodTypeAny\n    ? ZodDefaultV3<T>\n    : T extends z4.SomeType\n    ? ZodDefaultV4<T>\n    : never;\nexport type InteropZodOptional<T = InteropZodObjectShape> =\n  T extends z3.ZodTypeAny\n    ? ZodOptionalV3<T>\n    : T extends z4.SomeType\n    ? ZodOptionalV4<T>\n    : never;\n\nexport type InteropZodObjectShape<\n  T extends InteropZodObject = InteropZodObject\n> = T extends z3.ZodObject<infer Shape>\n  ? { [K in keyof Shape]: Shape[K] }\n  : T extends z4.$ZodObject<infer Shape>\n  ? { [K in keyof Shape]: Shape[K] }\n  : never;\n\nexport type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;\n\n// Simplified type inference to avoid circular dependencies\nexport type InferInteropZodInput<T> = T extends z3.ZodType<\n  unknown,\n  z3.ZodTypeDef,\n  infer Input\n>\n  ? Input\n  : T extends z4.$ZodType<unknown, infer Input>\n  ? Input\n  : T extends { _zod: { input: infer Input } }\n  ? Input\n  : never;\n\nexport type InferInteropZodOutput<T> = T extends z3.ZodType<\n  infer Output,\n  z3.ZodTypeDef,\n  unknown\n>\n  ? Output\n  : T extends z4.$ZodType<infer Output, unknown>\n  ? Output\n  : T extends { _zod: { output: infer Output } }\n  ? Output\n  : never;\n\nexport type Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\nexport function isZodSchemaV4(\n  schema: unknown\n): schema is z4.$ZodType<unknown, unknown> {\n  if (typeof schema !== \"object\" || schema === null) {\n    return false;\n  }\n\n  const obj = schema as Record<string, unknown>;\n  if (!(\"_zod\" in obj)) {\n    return false;\n  }\n\n  const zod = obj._zod;\n  return (\n    typeof zod === \"object\" &&\n    zod !== null &&\n    \"def\" in (zod as Record<string, unknown>)\n  );\n}\n\nexport function isZodSchemaV3(\n  schema: unknown\n): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown> {\n  if (typeof schema !== \"object\" || schema === null) {\n    return false;\n  }\n\n  const obj = schema as Record<string, unknown>;\n  if (!(\"_def\" in obj) || \"_zod\" in obj) {\n    return false;\n  }\n\n  const def = obj._def;\n  return (\n    typeof def === \"object\" &&\n    def != null &&\n    \"typeName\" in (def as Record<string, unknown>)\n  );\n}\n\n/** Backward compatible isZodSchema for Zod 3 */\nexport function isZodSchema<\n  RunOutput extends Record<string, unknown> = Record<string, unknown>\n>(\n  schema: z3.ZodType<RunOutput> | Record<string, unknown>\n): schema is z3.ZodType<RunOutput> {\n  if (isZodSchemaV4(schema)) {\n    console.warn(\n      \"[WARNING] Attempting to use Zod 4 schema in a context where Zod 3 schema is expected. This may cause unexpected behavior.\"\n    );\n  }\n  return isZodSchemaV3(schema);\n}\n\n/**\n * Given either a Zod schema, or plain object, determine if the input is a Zod schema.\n *\n * @param {unknown} input\n * @returns {boolean} Whether or not the provided input is a Zod schema.\n */\nexport function isInteropZodSchema(input: unknown): input is InteropZodType {\n  if (!input) {\n    return false;\n  }\n  if (typeof input !== \"object\") {\n    return false;\n  }\n  if (Array.isArray(input)) {\n    return false;\n  }\n  if (\n    isZodSchemaV4(input) ||\n    isZodSchemaV3(input as z3.ZodType<Record<string, unknown>>)\n  ) {\n    return true;\n  }\n  return false;\n}\n\ntype InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;\n\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.\n * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport async function interopSafeParseAsync<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): Promise<InteropZodSafeParseResult<T>> {\n  if (isZodSchemaV4(schema)) {\n    try {\n      const data = await parseAsync(schema, input);\n      return {\n        success: true,\n        data,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        error: error as z3.ZodError<T>,\n      };\n    }\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return await schema.safeParseAsync(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {Promise<T>} A promise that resolves to the parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport async function interopParseAsync<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): Promise<T> {\n  if (isZodSchemaV4(schema)) {\n    return await parseAsync(schema, input);\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return await schema.parseAsync(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object\n * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)\n *   or the error (on failure).\n * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.\n */\nexport function interopSafeParse<T>(\n  schema: InteropZodType<T>,\n  input: unknown\n): InteropZodSafeParseResult<T> {\n  if (isZodSchemaV4(schema)) {\n    try {\n      const data = parse(schema, input);\n      return {\n        success: true,\n        data,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        error: error as z3.ZodError<T>,\n      };\n    }\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.safeParse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.\n * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.\n *\n * @template T - The expected output type of the schema.\n * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.\n * @param {unknown} input - The input value to parse.\n * @returns {T} The parsed value.\n * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.\n */\nexport function interopParse<T>(schema: InteropZodType<T>, input: unknown): T {\n  if (isZodSchemaV4(schema)) {\n    return parse(schema, input);\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.parse(input);\n  }\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Retrieves the description from a schema definition (v3, v4, or plain object), if available.\n *\n * @param {unknown} schema - The schema to extract the description from.\n * @returns {string | undefined} The description of the schema, or undefined if not present.\n */\nexport function getSchemaDescription(\n  schema: InteropZodType<unknown> | Record<string, unknown>\n): string | undefined {\n  if (isZodSchemaV4(schema)) {\n    return globalRegistry.get(schema)?.description;\n  }\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    return schema.description as string | undefined;\n  }\n  if (\"description\" in schema && typeof schema.description === \"string\") {\n    return schema.description;\n  }\n  return undefined;\n}\n\n/**\n * Determines if the provided Zod schema is \"shapeless\".\n * A shapeless schema is one that does not define any object shape,\n * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.\n * For ZodObject, it must have no shape keys to be considered shapeless.\n * ZodRecord schemas are considered shapeless since they define dynamic\n * key-value mappings without fixed keys.\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is shapeless, false otherwise.\n */\nexport function isShapelessZodSchema(schema: unknown): boolean {\n  if (!isInteropZodSchema(schema)) {\n    return false;\n  }\n\n  // Check for v3 schemas\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    // @ts-expect-error - zod v3 types are not compatible with zod v4 types\n    const def = schema._def as { typeName?: string };\n\n    // ZodObject is only shaped if it has actual shape keys\n    if (def.typeName === \"ZodObject\") {\n      const obj = schema as { shape?: Record<string, unknown> };\n      return !obj.shape || Object.keys(obj.shape).length === 0;\n    }\n\n    // ZodRecord is shapeless (dynamic key-value mapping)\n    if (def.typeName === \"ZodRecord\") {\n      return true;\n    }\n  }\n\n  // Check for v4 schemas\n  if (isZodSchemaV4(schema)) {\n    const def = schema._zod.def;\n\n    // Object type is only shaped if it has actual shape keys\n    if (def.type === \"object\") {\n      const obj = schema as { shape?: Record<string, unknown> };\n      return !obj.shape || Object.keys(obj.shape).length === 0;\n    }\n\n    // Record type is shapeless (dynamic key-value mapping)\n    if (def.type === \"record\") {\n      return true;\n    }\n  }\n\n  // For other schemas, check if they have a `shape` property\n  // If they don't have shape, they're likely shapeless\n  if (typeof schema === \"object\" && schema !== null && !(\"shape\" in schema)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determines if the provided Zod schema should be treated as a simple string schema\n * that maps to DynamicTool. This aligns with the type-level constraint of\n * InteropZodType<string | undefined> which only matches basic string schemas.\n * If the provided schema is just z.string(), we can make the determination that\n * the tool is just a generic string tool that doesn't require any input validation.\n *\n * This function only returns true for basic ZodString schemas, including:\n * - Basic string schemas (z.string())\n * - String schemas with validations (z.string().min(1), z.string().email(), etc.)\n *\n * This function returns false for everything else, including:\n * - String schemas with defaults (z.string().default(\"value\"))\n * - Branded string schemas (z.string().brand<\"UserId\">())\n * - String schemas with catch operations (z.string().catch(\"default\"))\n * - Optional/nullable string schemas (z.string().optional())\n * - Transformed schemas (z.string().transform() or z.object().transform())\n * - Object or record schemas, even if they're empty\n * - Any other schema type\n *\n * @param schema The Zod schema to check.\n * @returns {boolean} True if the schema is a basic ZodString, false otherwise.\n */\nexport function isSimpleStringZodSchema(\n  schema: unknown\n): schema is InteropZodType<string | undefined> {\n  if (!isInteropZodSchema(schema)) {\n    return false;\n  }\n\n  // For v3 schemas\n  if (isZodSchemaV3(schema as z3.ZodType<Record<string, unknown>>)) {\n    // @ts-expect-error - zod v3 types are not compatible with zod v4 types\n    const def = schema._def as { typeName?: string };\n\n    // Only accept basic ZodString\n    return def.typeName === \"ZodString\";\n  }\n\n  // For v4 schemas\n  if (isZodSchemaV4(schema)) {\n    const def = schema._zod.def;\n\n    // Only accept basic string type\n    return def.type === \"string\";\n  }\n\n  return false;\n}\n\nexport function isZodObjectV3(obj: unknown): obj is ZodObjectV3 {\n  // Zod v3 object schemas have _def.typeName === \"ZodObject\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_def\" in obj &&\n    typeof obj._def === \"object\" &&\n    obj._def !== null &&\n    \"typeName\" in obj._def &&\n    obj._def.typeName === \"ZodObject\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function isZodObjectV4(obj: unknown): obj is z4.$ZodObject {\n  if (!isZodSchemaV4(obj)) return false;\n  // Zod v4 object schemas have _zod.def.type === \"object\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_zod\" in obj &&\n    typeof obj._zod === \"object\" &&\n    obj._zod !== null &&\n    \"def\" in obj._zod &&\n    typeof obj._zod.def === \"object\" &&\n    obj._zod.def !== null &&\n    \"type\" in obj._zod.def &&\n    obj._zod.def.type === \"object\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function isZodArrayV4(obj: unknown): obj is z4.$ZodArray {\n  if (!isZodSchemaV4(obj)) return false;\n  // Zod v4 array schemas have _zod.def.type === \"array\"\n  if (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"_zod\" in obj &&\n    typeof obj._zod === \"object\" &&\n    obj._zod !== null &&\n    \"def\" in obj._zod &&\n    typeof obj._zod.def === \"object\" &&\n    obj._zod.def !== null &&\n    \"type\" in obj._zod.def &&\n    obj._zod.def.type === \"array\"\n  ) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).\n *\n * @param obj The value to check.\n * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.\n */\nexport function isInteropZodObject(obj: unknown): obj is InteropZodObject {\n  if (isZodObjectV3(obj)) return true;\n  if (isZodObjectV4(obj)) return true;\n  return false;\n}\n\n/**\n * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObjectShape<T>} The shape of the object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function getInteropZodObjectShape<T extends InteropZodObject>(\n  schema: T\n): InteropZodObjectShape<T> {\n  if (isZodSchemaV3(schema)) {\n    return schema.shape;\n  }\n  if (isZodSchemaV4(schema)) {\n    return schema._zod.def.shape as InteropZodObjectShape<T>;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {InteropZodObjectShape} extension - The fields to add to the schema.\n * @returns {InteropZodObject} The extended Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function extendInteropZodObject<T extends InteropZodObject>(\n  schema: T,\n  extension: InteropZodObjectShape\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    return schema.extend(extension as z3.ZodRawShape);\n  }\n  if (isZodSchemaV4(schema)) {\n    return util.extend(schema, extension);\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a partial version of a Zod object schema, making all fields optional.\n * Supports both Zod v3 and v4.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @returns {InteropZodObject} The partial Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectPartial<T extends InteropZodObject>(\n  schema: T\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    // z3: .partial() exists and works as expected\n    return schema.partial();\n  }\n  if (isZodSchemaV4(schema)) {\n    // z4: util.partial exists and works as expected\n    return util.partial($ZodOptional, schema, undefined);\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a strict version of a Zod object schema, disallowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies strictness\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply strictness recursively to nested objects/arrays.\n * @returns {InteropZodObject} The strict Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectStrict<T extends InteropZodObject>(\n  schema: T,\n  recursive = false\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema.strict();\n  }\n  if (isZodObjectV4(schema)) {\n    const outputShape: Mutable<z4.$ZodShape> = schema._zod.def.shape;\n    if (recursive) {\n      for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {\n        // If the shape key is a v4 object schema, we need to make it strict\n        if (isZodObjectV4(keySchema)) {\n          const outputSchema = interopZodObjectStrict(keySchema, recursive);\n          outputShape[key] = outputSchema as ZodObjectV4;\n        }\n        // If the shape key is a v4 array schema, we need to make the element\n        // schema strict if it's an object schema\n        else if (isZodArrayV4(keySchema)) {\n          let elementSchema = keySchema._zod.def.element;\n          if (isZodObjectV4(elementSchema)) {\n            elementSchema = interopZodObjectStrict(\n              elementSchema,\n              recursive\n            ) as ZodObjectV4;\n          }\n          outputShape[key] = clone(keySchema, {\n            ...keySchema._zod.def,\n            element: elementSchema,\n          });\n        }\n        // Otherwise, just use the keySchema\n        else {\n          outputShape[key] = keySchema;\n        }\n        // Assign meta fields to the keySchema\n        const meta = globalRegistry.get(keySchema);\n        if (meta) globalRegistry.add(outputShape[key], meta);\n      }\n    }\n    const modifiedSchema = clone<ZodObjectV4>(schema, {\n      ...schema._zod.def,\n      shape: outputShape,\n      catchall: _never($ZodNever),\n    });\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(modifiedSchema, meta);\n    return modifiedSchema;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a passthrough version of a Zod object schema, allowing unknown keys.\n * Supports both Zod v3 and v4 object schemas. If `recursive` is true, applies passthrough\n * recursively to all nested object schemas and arrays of object schemas.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {boolean} [recursive=false] - Whether to apply passthrough recursively to nested objects/arrays.\n * @returns {InteropZodObject} The passthrough Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectPassthrough<T extends InteropZodObject>(\n  schema: T,\n  recursive = false\n): InteropZodObject {\n  if (isZodObjectV3(schema)) {\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema.passthrough();\n  }\n  if (isZodObjectV4(schema)) {\n    const outputShape: Mutable<z4.$ZodShape> = schema._zod.def.shape;\n    if (recursive) {\n      for (const [key, keySchema] of Object.entries(schema._zod.def.shape)) {\n        // If the shape key is a v4 object schema, we need to make it passthrough\n        if (isZodObjectV4(keySchema)) {\n          const outputSchema = interopZodObjectPassthrough(\n            keySchema,\n            recursive\n          );\n          outputShape[key] = outputSchema as ZodObjectV4;\n        }\n        // If the shape key is a v4 array schema, we need to make the element\n        // schema passthrough if it's an object schema\n        else if (isZodArrayV4(keySchema)) {\n          let elementSchema = keySchema._zod.def.element;\n          if (isZodObjectV4(elementSchema)) {\n            elementSchema = interopZodObjectPassthrough(\n              elementSchema,\n              recursive\n            ) as ZodObjectV4;\n          }\n          outputShape[key] = clone(keySchema, {\n            ...keySchema._zod.def,\n            element: elementSchema,\n          });\n        }\n        // Otherwise, just use the keySchema\n        else {\n          outputShape[key] = keySchema;\n        }\n        // Assign meta fields to the keySchema\n        const meta = globalRegistry.get(keySchema);\n        if (meta) globalRegistry.add(outputShape[key], meta);\n      }\n    }\n    const modifiedSchema = clone<ZodObjectV4>(schema, {\n      ...schema._zod.def,\n      shape: outputShape,\n      catchall: _unknown($ZodUnknown),\n    });\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(modifiedSchema, meta);\n    return modifiedSchema;\n  }\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n\n/**\n * Returns a getter function for the default value of a Zod schema, if one is defined.\n * Supports both Zod v3 and v4 schemas. If the schema has a default value,\n * the returned function will return that value when called. If no default is defined,\n * returns undefined.\n *\n * @template T - The type of the Zod schema.\n * @param {T} schema - The Zod schema instance (either v3 or v4).\n * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.\n */\nexport function getInteropZodDefaultGetter<T extends InteropZodType>(\n  schema: T\n): (() => InferInteropZodOutput<T>) | undefined {\n  if (isZodSchemaV3(schema)) {\n    try {\n      const defaultValue = schema.parse(undefined);\n      return () => defaultValue as InferInteropZodOutput<T>;\n    } catch {\n      return undefined;\n    }\n  }\n  if (isZodSchemaV4(schema)) {\n    try {\n      const defaultValue = parse(schema, undefined);\n      return () => defaultValue as InferInteropZodOutput<T>;\n    } catch {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nfunction isZodTransformV3(\n  schema: InteropZodType\n): schema is z3.ZodEffects<z3.ZodTypeAny> {\n  return (\n    isZodSchemaV3(schema) &&\n    \"typeName\" in schema._def &&\n    schema._def.typeName === \"ZodEffects\"\n  );\n}\n\nfunction isZodTransformV4(schema: InteropZodType): schema is z4.$ZodPipe {\n  return isZodSchemaV4(schema) && schema._zod.def.type === \"pipe\";\n}\n\n/**\n * Returns the input type of a Zod transform schema, for both v3 and v4.\n * If the schema is not a transform, returns undefined. If `recursive` is true,\n * recursively processes nested object schemas and arrays of object schemas.\n *\n * @param schema - The Zod schema instance (v3 or v4)\n * @param {boolean} [recursive=false] - Whether to recursively process nested objects/arrays.\n * @returns The input Zod schema of the transform, or undefined if not a transform\n */\nexport function interopZodTransformInputSchema(\n  schema: InteropZodType,\n  recursive = false\n): InteropZodType {\n  // Zod v3: ._def.schema is the input schema for ZodEffects (transform)\n  if (isZodSchemaV3(schema)) {\n    if (isZodTransformV3(schema)) {\n      return interopZodTransformInputSchema(schema._def.schema, recursive);\n    }\n    // TODO: v3 schemas aren't recursively handled here\n    // (currently not necessary since zodToJsonSchema handles this)\n    return schema;\n  }\n\n  // Zod v4: _def.type is the input schema for ZodEffects (transform)\n  if (isZodSchemaV4(schema)) {\n    let outputSchema: InteropZodType = schema;\n    if (isZodTransformV4(schema)) {\n      outputSchema = interopZodTransformInputSchema(\n        schema._zod.def.in,\n        recursive\n      );\n    }\n    if (recursive) {\n      // Handle nested object schemas\n      if (isZodObjectV4(outputSchema)) {\n        const outputShape: Mutable<z4.$ZodShape> = outputSchema._zod.def.shape;\n        for (const [key, keySchema] of Object.entries(\n          outputSchema._zod.def.shape\n        )) {\n          outputShape[key] = interopZodTransformInputSchema(\n            keySchema,\n            recursive\n          ) as z4.$ZodType;\n        }\n        outputSchema = clone<ZodObjectV4>(outputSchema, {\n          ...outputSchema._zod.def,\n          shape: outputShape,\n        });\n      }\n      // Handle nested array schemas\n      else if (isZodArrayV4(outputSchema)) {\n        const elementSchema = interopZodTransformInputSchema(\n          outputSchema._zod.def.element,\n          recursive\n        );\n        outputSchema = clone<z4.$ZodArray>(outputSchema, {\n          ...outputSchema._zod.def,\n          element: elementSchema as z4.$ZodType,\n        });\n      }\n    }\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(outputSchema as z4.$ZodType, meta);\n    return outputSchema;\n  }\n\n  throw new Error(\"Schema must be an instance of z3.ZodType or z4.$ZodType\");\n}\n\n/**\n * Creates a modified version of a Zod object schema where fields matching a predicate are made optional.\n * Supports both Zod v3 and v4 schemas and preserves the original schema version.\n *\n * @template T - The type of the Zod object schema.\n * @param {T} schema - The Zod object schema instance (either v3 or v4).\n * @param {(key: string, value: InteropZodType) => boolean} predicate - Function to determine which fields should be optional.\n * @returns {InteropZodObject} The modified Zod object schema.\n * @throws {Error} If the schema is not a Zod v3 or v4 object.\n */\nexport function interopZodObjectMakeFieldsOptional<T extends InteropZodObject>(\n  schema: T,\n  predicate: (key: string, value: InteropZodType) => boolean\n): InteropZodObject {\n  if (isZodSchemaV3(schema)) {\n    const shape = getInteropZodObjectShape(schema);\n    const modifiedShape: Record<string, z3.ZodTypeAny> = {};\n\n    for (const [key, value] of Object.entries(shape)) {\n      if (predicate(key, value)) {\n        // Make this field optional using v3 methods\n        modifiedShape[key] = (value as z3.ZodTypeAny).optional();\n      } else {\n        // Keep field as-is\n        modifiedShape[key] = value;\n      }\n    }\n\n    // Use v3's extend method to create a new schema with the modified shape\n    return schema.extend(modifiedShape as z3.ZodRawShape);\n  }\n\n  if (isZodSchemaV4(schema)) {\n    const shape = getInteropZodObjectShape(schema);\n    const outputShape: Mutable<z4.$ZodShape> = { ...schema._zod.def.shape };\n\n    for (const [key, value] of Object.entries(shape)) {\n      if (predicate(key, value)) {\n        // Make this field optional using v4 methods\n        outputShape[key] = new $ZodOptional({\n          type: \"optional\" as const,\n          innerType: value as z4.$ZodType,\n        });\n      }\n      // Otherwise keep the field as-is (already in outputShape)\n    }\n\n    const modifiedSchema = clone<ZodObjectV4>(schema, {\n      ...schema._zod.def,\n      shape: outputShape,\n    });\n\n    // Preserve metadata\n    const meta = globalRegistry.get(schema);\n    if (meta) globalRegistry.add(modifiedSchema, meta);\n\n    return modifiedSchema;\n  }\n\n  throw new Error(\n    \"Schema must be an instance of z3.ZodObject or z4.$ZodObject\"\n  );\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.6",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {