@langchain/core 0.3.57 → 0.3.58

package/dist/utils/types/zod.cjs

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInteropZodDefaultGetter = exports.interopZodObjectPassthrough = exports.interopZodObjectPartial = exports.extendInteropZodObject = exports.getInteropZodObjectShape = exports.isInteropZodObject = exports.isSimpleStringZodSchema = exports.isShapelessZodSchema = exports.getSchemaDescription = exports.interopParse = exports.interopSafeParse = exports.interopParseAsync = exports.interopSafeParseAsync = exports.isInteropZodSchema = exports.isZodSchema = exports.isZodSchemaV3 = exports.isZodSchemaV4 = void 0;
+const core_1 = require("zod/v4/core");
+function isZodSchemaV4(schema) {
+    if (typeof schema !== "object" || schema === null) {
+        return false;
+    }
+    const obj = schema;
+    if (!("_zod" in obj)) {
+        return false;
+    }
+    const zod = obj._zod;
+    return (typeof zod === "object" &&
+        zod !== null &&
+        "def" in zod);
+}
+exports.isZodSchemaV4 = isZodSchemaV4;
+function isZodSchemaV3(schema) {
+    if (typeof schema !== "object" || schema === null) {
+        return false;
+    }
+    const obj = schema;
+    if (!("_def" in obj) || "_zod" in obj) {
+        return false;
+    }
+    const def = obj._def;
+    return (typeof def === "object" &&
+        def != null &&
+        "typeName" in def);
+}
+exports.isZodSchemaV3 = isZodSchemaV3;
+/** Backward compatible isZodSchema for Zod 3 */
+function isZodSchema(schema) {
+    if (isZodSchemaV4(schema)) {
+        console.warn("[WARNING] Attempting to use Zod 4 schema in a context where Zod 3 schema is expected. This may cause unexpected behavior.");
+    }
+    return isZodSchemaV3(schema);
+}
+exports.isZodSchema = isZodSchema;
+/**
+ * Given either a Zod schema, or plain object, determine if the input is a Zod schema.
+ *
+ * @param {unknown} input
+ * @returns {boolean} Whether or not the provided input is a Zod schema.
+ */
+function isInteropZodSchema(input) {
+    if (!input) {
+        return false;
+    }
+    if (typeof input !== "object") {
+        return false;
+    }
+    if (Array.isArray(input)) {
+        return false;
+    }
+    if (isZodSchemaV4(input) ||
+        isZodSchemaV3(input)) {
+        return true;
+    }
+    return false;
+}
+exports.isInteropZodSchema = isInteropZodSchema;
+/**
+ * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.
+ * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.
+ * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.
+ */
+async function interopSafeParseAsync(schema, input) {
+    if (isZodSchemaV4(schema)) {
+        try {
+            const data = await (0, core_1.parseAsync)(schema, input);
+            return {
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+            };
+        }
+    }
+    if (isZodSchemaV3(schema)) {
+        return schema.safeParse(input);
+    }
+    throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
+}
+exports.interopSafeParseAsync = interopSafeParseAsync;
+/**
+ * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.
+ * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {Promise<T>} A promise that resolves to the parsed value.
+ * @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 (0, core_1.parse)(schema, input);
+    }
+    if (isZodSchemaV3(schema)) {
+        return schema.parse(input);
+    }
+    throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
+}
+exports.interopParseAsync = interopParseAsync;
+/**
+ * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object
+ * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)
+ *   or the error (on failure).
+ * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.
+ */
+function interopSafeParse(schema, input) {
+    if (isZodSchemaV4(schema)) {
+        try {
+            const data = (0, core_1.parse)(schema, input);
+            return {
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+            };
+        }
+    }
+    if (isZodSchemaV3(schema)) {
+        return schema.safeParse(input);
+    }
+    throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
+}
+exports.interopSafeParse = interopSafeParse;
+/**
+ * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.
+ * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {T} The parsed value.
+ * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.
+ */
+function interopParse(schema, input) {
+    if (isZodSchemaV4(schema)) {
+        return (0, core_1.parse)(schema, input);
+    }
+    if (isZodSchemaV3(schema)) {
+        return schema.parse(input);
+    }
+    throw new Error("Schema must be an instance of z3.ZodType or z4.$ZodType");
+}
+exports.interopParse = interopParse;
+/**
+ * Retrieves the description from a schema definition (v3, v4, or plain object), if available.
+ *
+ * @param {unknown} schema - The schema to extract the description from.
+ * @returns {string | undefined} The description of the schema, or undefined if not present.
+ */
+function getSchemaDescription(schema) {
+    if (isZodSchemaV4(schema)) {
+        return core_1.globalRegistry.get(schema)?.description;
+    }
+    if (isZodSchemaV3(schema)) {
+        return schema.description;
+    }
+    if ("description" in schema && typeof schema.description === "string") {
+        return schema.description;
+    }
+    return undefined;
+}
+exports.getSchemaDescription = getSchemaDescription;
+/**
+ * Determines if the provided Zod schema is "shapeless".
+ * A shapeless schema is one that does not define any object shape,
+ * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.
+ * For ZodObject, it must have no shape keys to be considered shapeless.
+ * ZodRecord schemas are considered shapeless since they define dynamic
+ * key-value mappings without fixed keys.
+ *
+ * @param schema The Zod schema to check.
+ * @returns {boolean} True if the schema is shapeless, false otherwise.
+ */
+function isShapelessZodSchema(schema) {
+    if (!isInteropZodSchema(schema)) {
+        return false;
+    }
+    // Check for v3 schemas
+    if (isZodSchemaV3(schema)) {
+        // @ts-expect-error - zod v3 types are not compatible with zod v4 types
+        const def = schema._def;
+        // ZodObject is only shaped if it has actual shape keys
+        if (def.typeName === "ZodObject") {
+            const obj = schema;
+            return !obj.shape || Object.keys(obj.shape).length === 0;
+        }
+        // ZodRecord is shapeless (dynamic key-value mapping)
+        if (def.typeName === "ZodRecord") {
+            return true;
+        }
+    }
+    // Check for v4 schemas
+    if (isZodSchemaV4(schema)) {
+        const def = schema._zod.def;
+        // Object type is only shaped if it has actual shape keys
+        if (def.type === "object") {
+            const obj = schema;
+            return !obj.shape || Object.keys(obj.shape).length === 0;
+        }
+        // Record type is shapeless (dynamic key-value mapping)
+        if (def.type === "record") {
+            return true;
+        }
+    }
+    // For other schemas, check if they have a `shape` property
+    // If they don't have shape, they're likely shapeless
+    if (typeof schema === "object" && schema !== null && !("shape" in schema)) {
+        return true;
+    }
+    return false;
+}
+exports.isShapelessZodSchema = isShapelessZodSchema;
+/**
+ * Determines if the provided Zod schema should be treated as a simple string schema
+ * that maps to DynamicTool. This aligns with the type-level constraint of
+ * InteropZodType<string | undefined> which only matches basic string schemas.
+ * If the provided schema is just z.string(), we can make the determination that
+ * the tool is just a generic string tool that doesn't require any input validation.
+ *
+ * This function only returns true for basic ZodString schemas, including:
+ * - Basic string schemas (z.string())
+ * - String schemas with validations (z.string().min(1), z.string().email(), etc.)
+ *
+ * This function returns false for everything else, including:
+ * - String schemas with defaults (z.string().default("value"))
+ * - Branded string schemas (z.string().brand<"UserId">())
+ * - String schemas with catch operations (z.string().catch("default"))
+ * - Optional/nullable string schemas (z.string().optional())
+ * - Transformed schemas (z.string().transform() or z.object().transform())
+ * - Object or record schemas, even if they're empty
+ * - Any other schema type
+ *
+ * @param schema The Zod schema to check.
+ * @returns {boolean} True if the schema is a basic ZodString, false otherwise.
+ */
+function isSimpleStringZodSchema(schema) {
+    if (!isInteropZodSchema(schema)) {
+        return false;
+    }
+    // For v3 schemas
+    if (isZodSchemaV3(schema)) {
+        // @ts-expect-error - zod v3 types are not compatible with zod v4 types
+        const def = schema._def;
+        // Only accept basic ZodString
+        return def.typeName === "ZodString";
+    }
+    // For v4 schemas
+    if (isZodSchemaV4(schema)) {
+        const def = schema._zod.def;
+        // Only accept basic string type
+        return def.type === "string";
+    }
+    return false;
+}
+exports.isSimpleStringZodSchema = isSimpleStringZodSchema;
+/**
+ * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).
+ *
+ * @param obj The value to check.
+ * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.
+ */
+function isInteropZodObject(obj) {
+    if (isZodSchemaV3(obj)) {
+        // Zod v3 object schemas have _def.typeName === "ZodObject"
+        if (typeof obj === "object" &&
+            obj !== null &&
+            "_def" in obj &&
+            typeof obj._def === "object" &&
+            obj._def !== null &&
+            "typeName" in obj._def &&
+            obj._def.typeName === "ZodObject") {
+            return true;
+        }
+    }
+    if (isZodSchemaV4(obj)) {
+        // Zod v4 object schemas have _zod.def.type === "object"
+        if (typeof obj === "object" &&
+            obj !== null &&
+            "_zod" in obj &&
+            typeof obj._zod === "object" &&
+            obj._zod !== null &&
+            "def" in obj._zod &&
+            typeof obj._zod.def === "object" &&
+            obj._zod.def !== null &&
+            "type" in obj._zod.def &&
+            obj._zod.def.type === "object") {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isInteropZodObject = isInteropZodObject;
+/**
+ * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @returns {InteropZodObjectShape<T>} The shape of the object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+function getInteropZodObjectShape(schema) {
+    if (isZodSchemaV3(schema)) {
+        return schema.shape;
+    }
+    if (isZodSchemaV4(schema)) {
+        return schema._zod.def.shape;
+    }
+    throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
+exports.getInteropZodObjectShape = getInteropZodObjectShape;
+/**
+ * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {InteropZodObjectShape} extension - The fields to add to the schema.
+ * @returns {InteropZodObject} The extended Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+function extendInteropZodObject(schema, extension) {
+    if (isZodSchemaV3(schema)) {
+        return schema.extend(extension);
+    }
+    if (isZodSchemaV4(schema)) {
+        return core_1.util.extend(schema, extension);
+    }
+    throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
+exports.extendInteropZodObject = extendInteropZodObject;
+/**
+ * Returns a partial version of a Zod object schema, making all fields optional.
+ * Supports both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @returns {InteropZodObject} The partial Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+function interopZodObjectPartial(schema) {
+    if (isZodSchemaV3(schema)) {
+        // z3: .partial() exists and works as expected
+        return schema.partial();
+    }
+    if (isZodSchemaV4(schema)) {
+        // z4: util.partial exists and works as expected
+        return core_1.util.partial(core_1.$ZodOptional, schema, undefined);
+    }
+    throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
+exports.interopZodObjectPartial = interopZodObjectPartial;
+function interopZodObjectPassthrough(schema) {
+    if (isInteropZodObject(schema)) {
+        if (isZodSchemaV3(schema)) {
+            return schema.passthrough();
+        }
+        if (isZodSchemaV4(schema)) {
+            // Type reassign since ZodObjectV4 assumes that generics should be washed
+            const objectSchema = schema;
+            return (0, core_1.clone)(objectSchema, {
+                ...objectSchema._zod.def,
+                catchall: (0, core_1._unknown)(core_1.$ZodUnknown),
+            });
+        }
+    }
+    throw new Error("Schema must be an instance of z3.ZodObject or z4.$ZodObject");
+}
+exports.interopZodObjectPassthrough = interopZodObjectPassthrough;
+/**
+ * Returns a getter function for the default value of a Zod schema, if one is defined.
+ * Supports both Zod v3 and v4 schemas. If the schema has a default value,
+ * the returned function will return that value when called. If no default is defined,
+ * returns undefined.
+ *
+ * @template T - The type of the Zod schema.
+ * @param {T} schema - The Zod schema instance (either v3 or v4).
+ * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.
+ */
+function getInteropZodDefaultGetter(schema) {
+    if (isZodSchemaV3(schema)) {
+        try {
+            const defaultValue = schema.parse(undefined);
+            return () => defaultValue;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (isZodSchemaV4(schema)) {
+        try {
+            const defaultValue = (0, core_1.parse)(schema, undefined);
+            return () => defaultValue;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+exports.getInteropZodDefaultGetter = getInteropZodDefaultGetter;

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

@@ -0,0 +1,173 @@
+import type * as z3 from "zod/v3";
+import type * as z4 from "zod/v4/core";
+export type ZodStringV3 = z3.ZodString;
+export type ZodStringV4 = z4.$ZodType<string, unknown>;
+export type ZodObjectV3 = z3.ZodObject<any, any, any, any>;
+export type ZodObjectV4 = z4.$ZodObject;
+export type InteropZodType<Output = any, Input = Output> = z3.ZodType<Output, z3.ZodTypeDef, Input> | z4.$ZodType<Output, Input>;
+export type InteropZodObject = ZodObjectV3 | ZodObjectV4;
+export 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;
+export type InteropZodIssue = z3.ZodIssue | z4.$ZodIssue;
+export type InferInteropZodInput<T> = T extends z3.ZodType<unknown, z3.ZodTypeDef, infer Input> ? Input : T extends z4.$ZodType<unknown, infer Input> ? Input : T extends {
+    _zod: {
+        input: infer Input;
+    };
+} ? Input : never;
+export type InferInteropZodOutput<T> = T extends z3.ZodType<infer Output, z3.ZodTypeDef, unknown> ? Output : T extends z4.$ZodType<infer Output, unknown> ? Output : T extends {
+    _zod: {
+        output: infer Output;
+    };
+} ? Output : never;
+export declare function isZodSchemaV4(schema: unknown): schema is z4.$ZodType<unknown, unknown>;
+export declare function isZodSchemaV3(schema: unknown): schema is z3.ZodType<unknown, z3.ZodTypeDef, unknown>;
+/** Backward compatible isZodSchema for Zod 3 */
+export declare function isZodSchema<RunOutput extends Record<string, unknown> = Record<string, unknown>>(schema: z3.ZodType<RunOutput> | Record<string, unknown>): schema is z3.ZodType<RunOutput>;
+/**
+ * Given either a Zod schema, or plain object, determine if the input is a Zod schema.
+ *
+ * @param {unknown} input
+ * @returns {boolean} Whether or not the provided input is a Zod schema.
+ */
+export declare function isInteropZodSchema(input: unknown): input is InteropZodType;
+type InteropZodSafeParseResult<T> = z3.SafeParseReturnType<T, T>;
+/**
+ * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns a safe parse result.
+ * This function handles both Zod v3 and v4 schemas, returning a result object indicating success or failure.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {Promise<InteropZodSafeParseResult<T>>} A promise that resolves to a safe parse result object.
+ * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.
+ */
+export declare function interopSafeParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<InteropZodSafeParseResult<T>>;
+/**
+ * Asynchronously parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.
+ * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {Promise<T>} A promise that resolves to the parsed value.
+ * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.
+ */
+export declare function interopParseAsync<T>(schema: InteropZodType<T>, input: unknown): Promise<T>;
+/**
+ * Safely parses the input using the provided Zod schema (v3 or v4) and returns a result object
+ * indicating success or failure. This function is compatible with both Zod v3 and v4 schemas.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {InteropZodSafeParseResult<T>} An object with either the parsed data (on success)
+ *   or the error (on failure).
+ * @throws {Error} If the schema is not a recognized Zod v3 or v4 schema.
+ */
+export declare function interopSafeParse<T>(schema: InteropZodType<T>, input: unknown): InteropZodSafeParseResult<T>;
+/**
+ * Parses the input using the provided Zod schema (v3 or v4) and returns the parsed value.
+ * Throws an error if parsing fails or if the schema is not a recognized Zod v3 or v4 schema.
+ *
+ * @template T - The expected output type of the schema.
+ * @param {InteropZodType<T>} schema - The Zod schema (v3 or v4) to use for parsing.
+ * @param {unknown} input - The input value to parse.
+ * @returns {T} The parsed value.
+ * @throws {Error} If parsing fails or the schema is not a recognized Zod v3 or v4 schema.
+ */
+export declare function interopParse<T>(schema: InteropZodType<T>, input: unknown): T;
+/**
+ * Retrieves the description from a schema definition (v3, v4, or plain object), if available.
+ *
+ * @param {unknown} schema - The schema to extract the description from.
+ * @returns {string | undefined} The description of the schema, or undefined if not present.
+ */
+export declare function getSchemaDescription(schema: InteropZodType<unknown> | Record<string, unknown>): string | undefined;
+/**
+ * Determines if the provided Zod schema is "shapeless".
+ * A shapeless schema is one that does not define any object shape,
+ * such as ZodString, ZodNumber, ZodBoolean, ZodAny, etc.
+ * For ZodObject, it must have no shape keys to be considered shapeless.
+ * ZodRecord schemas are considered shapeless since they define dynamic
+ * key-value mappings without fixed keys.
+ *
+ * @param schema The Zod schema to check.
+ * @returns {boolean} True if the schema is shapeless, false otherwise.
+ */
+export declare function isShapelessZodSchema(schema: unknown): boolean;
+/**
+ * Determines if the provided Zod schema should be treated as a simple string schema
+ * that maps to DynamicTool. This aligns with the type-level constraint of
+ * InteropZodType<string | undefined> which only matches basic string schemas.
+ * If the provided schema is just z.string(), we can make the determination that
+ * the tool is just a generic string tool that doesn't require any input validation.
+ *
+ * This function only returns true for basic ZodString schemas, including:
+ * - Basic string schemas (z.string())
+ * - String schemas with validations (z.string().min(1), z.string().email(), etc.)
+ *
+ * This function returns false for everything else, including:
+ * - String schemas with defaults (z.string().default("value"))
+ * - Branded string schemas (z.string().brand<"UserId">())
+ * - String schemas with catch operations (z.string().catch("default"))
+ * - Optional/nullable string schemas (z.string().optional())
+ * - Transformed schemas (z.string().transform() or z.object().transform())
+ * - Object or record schemas, even if they're empty
+ * - Any other schema type
+ *
+ * @param schema The Zod schema to check.
+ * @returns {boolean} True if the schema is a basic ZodString, false otherwise.
+ */
+export declare function isSimpleStringZodSchema(schema: unknown): schema is InteropZodType<string | undefined>;
+/**
+ * Determines if the provided value is an InteropZodObject (Zod v3 or v4 object schema).
+ *
+ * @param obj The value to check.
+ * @returns {boolean} True if the value is a Zod v3 or v4 object schema, false otherwise.
+ */
+export declare function isInteropZodObject(obj: unknown): obj is InteropZodObject;
+/**
+ * Retrieves the shape (fields) of a Zod object schema, supporting both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @returns {InteropZodObjectShape<T>} The shape of the object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export declare function getInteropZodObjectShape<T extends InteropZodObject>(schema: T): InteropZodObjectShape<T>;
+/**
+ * Extends a Zod object schema with additional fields, supporting both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @param {InteropZodObjectShape} extension - The fields to add to the schema.
+ * @returns {InteropZodObject} The extended Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export declare function extendInteropZodObject<T extends InteropZodObject>(schema: T, extension: InteropZodObjectShape): InteropZodObject;
+/**
+ * Returns a partial version of a Zod object schema, making all fields optional.
+ * Supports both Zod v3 and v4.
+ *
+ * @template T - The type of the Zod object schema.
+ * @param {T} schema - The Zod object schema instance (either v3 or v4).
+ * @returns {InteropZodObject} The partial Zod object schema.
+ * @throws {Error} If the schema is not a Zod v3 or v4 object.
+ */
+export declare function interopZodObjectPartial<T extends InteropZodObject>(schema: T): InteropZodObject;
+export declare function interopZodObjectPassthrough<T extends InteropZodObject>(schema: T): InteropZodObject;
+/**
+ * Returns a getter function for the default value of a Zod schema, if one is defined.
+ * Supports both Zod v3 and v4 schemas. If the schema has a default value,
+ * the returned function will return that value when called. If no default is defined,
+ * returns undefined.
+ *
+ * @template T - The type of the Zod schema.
+ * @param {T} schema - The Zod schema instance (either v3 or v4).
+ * @returns {(() => InferInteropZodOutput<T>) | undefined} A function that returns the default value, or undefined if no default is set.
+ */
+export declare function getInteropZodDefaultGetter<T extends InteropZodType>(schema: T): (() => InferInteropZodOutput<T>) | undefined;
+export {};