@orval/zod 8.19.0 → 8.21.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { buildDynamicScope, buildInlineDynamicScope, camel, compareVersions, generateMutator, getDynamicAnchorName, getFormDataFieldFileType, getNumberWord, getRefInfo, isBoolean, isDynamicReference, isNumber, isObject, isString, jsStringEscape, jsStringLiteralEscape, logVerbose, pascal, resolveDynamicRef, resolveRef, stringify } from "@orval/core";
+import jsesc from "jsesc";
 import { unique } from "remeda";
 //#region src/compatible-v4.ts
 const getZodPackageVersion = (packageJson) => {
@@ -26,6 +27,11 @@ const resolveIsZodV4 = (version, packageJson) => {
 	if (!packageJson || !getZodPackageVersion(packageJson)) return true;
 	return isZodVersionV4(packageJson);
 };
+const assertZodTarget = ({ variant, isZodV4 }) => {
+	if (variant === "mini" && !isZodV4) throw new Error("Zod Mini requires Zod 4 output. Use override.zod.version: 4 or install zod@^4 when override.zod.version is 'auto'.");
+};
+const getZodImportSource = (variant) => variant === "mini" ? "zod/mini" : "zod";
+const getZodTypeName = (variant) => variant === "mini" ? "ZodMiniType" : "ZodType";
 const getZodDateFormat = (isZodV4) => {
 	return isZodV4 ? "iso.date" : "date";
 };
@@ -54,7 +60,7 @@ const getLooseObjectFunctionName = (isZodV4) => {
 };
 //#endregion
 //#region src/index.ts
-const ZOD_DEPENDENCIES = [{
+const getZodDependencies = (_hasGlobalMutator, _hasParamsSerializerOptions, _packageJson, _httpClient, _hasTagsMutator, override) => [{
 	exports: [{
 		default: false,
 		name: "zod",
@@ -62,9 +68,8 @@ const ZOD_DEPENDENCIES = [{
 		namespaceImport: true,
 		values: true
 	}],
-	dependency: "zod"
+	dependency: getZodImportSource(override?.zod.variant)
 }];
-const getZodDependencies = () => ZOD_DEPENDENCIES;
 /**
 * values that may appear in "type". Equals SchemaObjectType
 */
@@ -110,6 +115,21 @@ const COERCIBLE_TYPES = new Set([
 	"bigint",
 	"date"
 ]);
+const PURE_COMMENT = "/*#__PURE__*/ ";
+const zodMiniCall = (fn, args = "") => `${PURE_COMMENT}zod.${fn}(${args})`;
+const zodMiniCoerceCall = (fn, args = "") => `${PURE_COMMENT}zod.coerce.${fn}(${args})`;
+/** Escapes string defaults for safe embedding in template literals. */
+function formatDefaultValue(value) {
+	if (isString(value)) return jsesc(value, {
+		quotes: "backtick",
+		wrap: true
+	});
+	if (Array.isArray(value)) return `[${value.map((item) => isString(item) ? jsesc(item, {
+		quotes: "backtick",
+		wrap: true
+	}) : formatDefaultValue(item)).join(", ")}]`;
+	return stringify(value) ?? "null";
+}
 const minAndMaxTypes = new Set([
 	"number",
 	"string",
@@ -135,6 +155,66 @@ const removeReadOnlyProperties = (schema) => {
 };
 const COMPONENT_SCHEMAS_REF_PATTERN = /^#\/components\/schemas\/[^/]+$/;
 const isComponentSchemaRef = (ref) => COMPONENT_SCHEMAS_REF_PATTERN.test(ref);
+const DISCRIMINATOR_MARK = "::discriminator::";
+const encodeDiscriminatorSeparator = (base, property) => `${base}${DISCRIMINATOR_MARK}${property}`;
+const decodeDiscriminatorSeparator = (fn) => {
+	const index = fn.indexOf(DISCRIMINATOR_MARK);
+	if (index === -1) return null;
+	return {
+		base: fn.slice(0, index),
+		property: fn.slice(index + 17)
+	};
+};
+const resolveUnionMemberSchema = (member, context) => {
+	if (member && "$ref" in member && typeof member.$ref === "string") return tryResolveRefSchema(member.$ref, context);
+	return member;
+};
+const isPlainObjectSchema = (schema) => {
+	if (!schema || schema.oneOf || schema.anyOf || schema.allOf) return false;
+	return schema.type === "object" || isObject(schema.properties) && Object.keys(schema.properties).length > 0;
+};
+const hasLiteralDiscriminator = (schema, property) => {
+	if (!schema || !isObject(schema.properties)) return false;
+	const propertySchema = schema.properties[property];
+	if (!isObject(propertySchema)) return false;
+	return propertySchema.const !== void 0 || Array.isArray(propertySchema.enum);
+};
+const collectDiscriminatorValues = (member, property, context) => {
+	const readValues = (schema) => {
+		if (!schema || !isObject(schema.properties)) return null;
+		const propertySchema = schema.properties[property];
+		if (!isObject(propertySchema)) return null;
+		const constValue = propertySchema.const;
+		if (constValue !== void 0) return [constValue];
+		const enumValues = propertySchema.enum;
+		if (Array.isArray(enumValues)) return enumValues;
+		return null;
+	};
+	const resolved = resolveUnionMemberSchema(member, context);
+	if (!resolved) return null;
+	if (resolved.allOf) {
+		const parts = resolved.allOf.map((part) => resolveUnionMemberSchema(part, context));
+		for (let index = parts.length - 1; index >= 0; index--) {
+			const values = readValues(parts[index]);
+			if (values) return values;
+		}
+		return null;
+	}
+	return readValues(resolved);
+};
+const isDiscriminatableMember = (member, property, useReusableSchemas, context) => {
+	const resolved = resolveUnionMemberSchema(member, context);
+	if (!resolved) return false;
+	if (resolved.oneOf || resolved.anyOf) return false;
+	if (resolved.allOf) {
+		if (useReusableSchemas) return false;
+		const parts = resolved.allOf.map((part) => resolveUnionMemberSchema(part, context));
+		if (!parts.every((part) => isPlainObjectSchema(part))) return false;
+		return parts.some((part) => hasLiteralDiscriminator(part, property));
+	}
+	if (!isPlainObjectSchema(resolved)) return false;
+	return hasLiteralDiscriminator(resolved, property);
+};
 const generateZodValidationSchemaDefinition = (schema, context, name, strict, isZodV4, rules) => {
 	if (!schema) return {
 		functions: [],
@@ -206,6 +286,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		schema = dereference(schema, context);
 	}
 	const useReusableSchemas = rules?.useReusableSchemas ?? false;
+	const urlEncoded = rules?.urlEncoded ?? false;
 	const consts = [];
 	const constNameRegistry = rules?.constNameRegistry ?? {};
 	const constsCounter = isNumber(constNameRegistry[name]) ? constNameRegistry[name] + 1 : 0;
@@ -239,6 +320,23 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 	if (schema.allOf || schema.oneOf || schema.anyOf) {
 		const separator = schema.allOf ? "allOf" : schema.oneOf ? "oneOf" : "anyOf";
 		const schemas = schema.allOf ?? schema.oneOf ?? schema.anyOf;
+		const discriminatorProperty = (() => {
+			if (!context.output?.override?.zod?.generateDiscriminatedUnion || !(schema.oneOf || schema.anyOf) || !schema.discriminator?.propertyName || schemas.length <= 1) return;
+			const property = schema.discriminator.propertyName;
+			if (!schemas.every((member) => isDiscriminatableMember(member, property, useReusableSchemas, context))) return;
+			const seenValues = /* @__PURE__ */ new Set();
+			for (const member of schemas) {
+				const values = collectDiscriminatorValues(member, property, context);
+				if (!values || values.length === 0) return void 0;
+				for (const value of values) {
+					const key = JSON.stringify(value);
+					if (seenValues.has(key)) return void 0;
+					seenValues.add(key);
+				}
+			}
+			return property;
+		})();
+		const unionSeparator = discriminatorProperty ? encodeDiscriminatorSeparator(separator, discriminatorProperty) : separator;
 		const allOfRequired = schema.allOf ? [...new Set([...schema.required ?? [], ...schemas.flatMap((member) => {
 			const memberRequired = ("$ref" in member && typeof member.$ref === "string" ? tryResolveRefSchema(member.$ref, context) : member)?.required;
 			return Array.isArray(memberRequired) ? memberRequired : [];
@@ -247,7 +345,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			required: true,
 			additionalRequired: allOfRequired,
 			constNameRegistry,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded
 		}));
 		if ((schema.allOf || schema.oneOf || schema.anyOf) && schema.properties) {
 			const additionalPropertiesSchema = {
@@ -261,17 +360,18 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				required: true,
 				additionalRequired: allOfRequired,
 				constNameRegistry,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded
 			});
 			if (schema.oneOf || schema.anyOf) functions.push(["allOf", [{
-				functions: [[separator, baseSchemas]],
+				functions: [[unionSeparator, baseSchemas]],
 				consts: []
 			}, additionalPropertiesDefinition]]);
 			else {
 				baseSchemas.push(additionalPropertiesDefinition);
 				functions.push([separator, baseSchemas]);
 			}
-		} else functions.push([separator, baseSchemas]);
+		} else functions.push([unionSeparator, baseSchemas]);
 		skipSwitchStatement = true;
 	}
 	let defaultVarName;
@@ -281,14 +381,14 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		if (schema.type === "string" && (schema.format === "date" || schema.format === "date-time") && context.output.override.useDates) defaultValue = `new Date(${JSON.stringify(schema.default)})`;
 		else if (isObject(schema.default)) {
 			const entries = Object.entries(schema.default).map(([key, value]) => {
-				if (isString(value)) return `${key}: ${JSON.stringify(value)} as const`;
-				if (Array.isArray(value)) return `${key}: [${value.map((item) => isString(item) ? `${JSON.stringify(item)} as const` : `${item}`).join(", ")}]`;
-				if (value === null || value === void 0 || isNumber(value) || isBoolean(value)) return `${key}: ${value}`;
+				const safeKey = JSON.stringify(key);
+				if (isString(value)) return `${safeKey}: ${JSON.stringify(value)} as const`;
+				if (Array.isArray(value)) return `${safeKey}: [${value.map((item) => isString(item) ? `${JSON.stringify(item)} as const` : `${item}`).join(", ")}]`;
+				if (value === null || value === void 0 || isNumber(value) || isBoolean(value)) return `${safeKey}: ${value}`;
 			}).join(", ");
 			defaultValue = entries.length === 0 ? `{}` : `{ ${entries} }`;
 		} else {
-			const rawStringified = stringify(schema.default);
-			defaultValue = rawStringified === void 0 ? "null" : rawStringified.replaceAll("'", "`");
+			defaultValue = formatDefaultValue(schema.default);
 			if (Array.isArray(schema.default) && type === "array" && schema.items && "enum" in schema.items && schema.default.length > 0) {
 				defaultVarName = defaultValue;
 				defaultValue = void 0;
@@ -304,7 +404,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		}, context, name, strict, isZodV4, {
 			required: true,
 			constNameRegistry,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded
 		}))]);
 		if (!required && nullable) functions.push(["nullish", void 0]);
 		else if (nullable) functions.push(["nullable", void 0]);
@@ -339,12 +440,14 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 					functions.push(["tuple", prefixItems.map((item, idx) => generateZodValidationSchemaDefinition(dereference(item, context), context, camel(`${name}-${idx}-item`), isZodV4, strict, {
 						required: true,
 						constNameRegistry,
-						useReusableSchemas
+						useReusableSchemas,
+						urlEncoded
 					}))]);
 					if (schema.items && (max ?? Number.POSITIVE_INFINITY) > prefixItems.length) functions.push(["rest", generateZodValidationSchemaDefinition(schema.items, context, camel(`${name}-item`), strict, isZodV4, {
 						required: true,
 						constNameRegistry,
-						useReusableSchemas
+						useReusableSchemas,
+						urlEncoded
 					})]);
 				}
 			}
@@ -353,7 +456,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			functions.push(["array", generateZodValidationSchemaDefinition(schema.items, context, camel(`${name}-item`), strict, isZodV4, {
 				required: true,
 				constNameRegistry,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded
 			})]);
 			break;
 		case "string":
@@ -362,11 +466,11 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push(["date", void 0]);
 				break;
 			}
-			if (schema.format === "binary") {
+			if (!urlEncoded && schema.format === "binary") {
 				functions.push(["instanceof", "File"]);
 				break;
 			}
-			if (schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding) {
+			if (!urlEncoded && schema.contentMediaType === "application/octet-stream" && !schema.contentEncoding) {
 				functions.push(["instanceof", "File"]);
 				break;
 			}
@@ -431,7 +535,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push([objectType, Object.keys(properties).map((key) => ({ [key]: rules?.propertyOverrides?.[key] ?? generateZodValidationSchemaDefinition(properties[key], context, camel(`${name}-${key}`), strict, isZodV4, {
 					required: requiredKeys.has(key),
 					constNameRegistry,
-					useReusableSchemas
+					useReusableSchemas,
+					urlEncoded
 				}) })).reduce((acc, curr) => ({
 					...acc,
 					...curr
@@ -449,7 +554,8 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				functions.push(["additionalProperties", generateZodValidationSchemaDefinition(isBoolean(schema.additionalProperties) ? {} : schema.additionalProperties, context, name, strict, isZodV4, {
 					required: true,
 					constNameRegistry,
-					useReusableSchemas
+					useReusableSchemas,
+					urlEncoded
 				})]);
 				break;
 			}
@@ -528,7 +634,7 @@ const PARAMS_MERGE_INTO_OPTIONS_VALIDATORS = new Set([
 	"iso.datetime",
 	"iso.time"
 ]);
-const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false, strict, isZodV4, preprocess, paramsInjection) => {
+const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false, strict, isZodV4, preprocess, paramsInjection, variant = "classic") => {
 	if (input.functions.length === 0) return {
 		zod: "",
 		consts: "",
@@ -562,6 +668,251 @@ const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false,
 		};
 		return `${paramsInjection.mutator.name}(${JSON.stringify(ctx)})`;
 	};
+	const shouldCoerce = (fn) => coerceTypes && (Array.isArray(coerceTypes) ? coerceTypes.includes(fn) : COERCIBLE_TYPES.has(fn));
+	const buildCombinedArgs = (fn, args, fieldPath) => {
+		const formattedArgs = formatFunctionArgs(args);
+		const paramsArg = buildParamsArg(fn, fieldPath);
+		if (paramsArg && formattedArgs && PARAMS_MERGE_INTO_OPTIONS_VALIDATORS.has(fn)) return `{ ...${formattedArgs}, ...${paramsArg} }`;
+		if (paramsArg) return formattedArgs ? `${formattedArgs}, ${paramsArg}` : paramsArg;
+		return formattedArgs;
+	};
+	const renderMiniDefinition = (definition, fieldPath = []) => {
+		let current;
+		const requireCurrent = (fn) => {
+			if (!current) throw new Error(`Cannot render zod mini ${fn} without a base schema`);
+			return current;
+		};
+		const renderObject = (objectArgs, objectType) => ({
+			kind: "object",
+			expr: `${zodMiniCall(objectType, `{
+${Object.entries(objectArgs).map(([key, schema]) => {
+				const rendered = renderMiniDefinition(schema, [...fieldPath, key]);
+				appendConstsChunk(schema.consts.join("\n"));
+				if (Array.isArray(coerceTypes) && coerceTypes.includes("array") && schema.functions.some(([fn]) => fn === "array")) return `  ${JSON.stringify(key)}: ${zodMiniCall("pipe", `${zodMiniCall("transform", "(value) => value === undefined || Array.isArray(value) ? value : [value]")}, ${rendered.expr}`)}`;
+				return `  ${JSON.stringify(key)}: ${rendered.expr}`;
+			}).join(",\n")}
+}`)}`
+		});
+		const mergeAllOfObjectsMini = (allOfArgs) => {
+			if (!(allOfArgs.length > 0 && allOfArgs.every((partSchema) => {
+				if (partSchema.functions.length === 0) return false;
+				const firstFn = partSchema.functions[0][0];
+				return firstFn === "object" || firstFn === "strictObject";
+			}))) return null;
+			const mergedProperties = {};
+			for (const partSchema of allOfArgs) {
+				if (partSchema.consts.length > 0) appendConstsChunk(partSchema.consts.join("\n"));
+				const objectFunctionIndex = partSchema.functions.findIndex(([fnName]) => fnName === "object" || fnName === "strictObject");
+				if (objectFunctionIndex !== -1) {
+					const objectArgs = partSchema.functions[objectFunctionIndex][1];
+					if (isObject(objectArgs)) Object.assign(mergedProperties, objectArgs);
+				}
+			}
+			return mergedProperties;
+		};
+		const renderDiscriminatedUnionMemberMini = (member) => {
+			if (member.functions[0]?.[0] === "allOf") {
+				const merged = mergeAllOfObjectsMini(member.functions[0][1]);
+				if (merged !== null) return renderObject(merged, getObjectFunctionName(true, strict)).expr;
+			}
+			appendConstsChunk(member.consts.join("\n"));
+			return renderMiniDefinition(member, fieldPath).expr;
+		};
+		for (let index = 0; index < definition.functions.length; index++) {
+			const [fn, args = ""] = definition.functions[index];
+			if (fn === "namedRef") {
+				const refArgs = args;
+				usedRefs.add(refArgs.name);
+				current = {
+					expr: `__REF_${refArgs.name}__`,
+					kind: "ref"
+				};
+				continue;
+			}
+			if (fn === "fileOrString") {
+				current = {
+					expr: zodMiniCall("union", `[${zodMiniCall("instanceof", "File")}, ${zodMiniCall("string")}]`),
+					kind: "union"
+				};
+				continue;
+			}
+			if (fn === "allOf") {
+				const allOfArgs = args;
+				const mergedProperties = strict ? mergeAllOfObjectsMini(allOfArgs) : null;
+				if (mergedProperties !== null) {
+					current = renderObject(mergedProperties, getObjectFunctionName(true, strict));
+					continue;
+				}
+				const rendered = allOfArgs.map((partSchema) => {
+					appendConstsChunk(partSchema.consts.join("\n"));
+					return renderMiniDefinition(partSchema, fieldPath).expr;
+				});
+				if (rendered.length === 0) {
+					current = { expr: "" };
+					continue;
+				}
+				current = {
+					expr: rendered.reduce((acc, value) => acc ? zodMiniCall("intersection", `${acc}, ${value}`) : value),
+					kind: "intersection"
+				};
+				continue;
+			}
+			const discriminator = decodeDiscriminatorSeparator(fn);
+			if (discriminator || fn === "oneOf" || fn === "anyOf") {
+				const unionArgs = args;
+				if (unionArgs.length === 1) {
+					appendConstsChunk(unionArgs[0].consts.join("\n"));
+					current = renderMiniDefinition(unionArgs[0], fieldPath);
+					continue;
+				}
+				if (discriminator) {
+					current = {
+						expr: zodMiniCall("discriminatedUnion", `'${jsStringEscape(discriminator.property)}', [${unionArgs.map((arg) => renderDiscriminatedUnionMemberMini(arg)).join(",")}]`),
+						kind: "union"
+					};
+					continue;
+				}
+				current = {
+					expr: zodMiniCall("union", `[${unionArgs.map((arg) => {
+						appendConstsChunk(arg.consts.join("\n"));
+						return renderMiniDefinition(arg, fieldPath).expr;
+					}).join(",")}]`),
+					kind: "union"
+				};
+				continue;
+			}
+			if (fn === "additionalProperties") {
+				const additionalPropertiesArgs = args;
+				const rendered = renderMiniDefinition(additionalPropertiesArgs, fieldPath);
+				if (Array.isArray(additionalPropertiesArgs.consts)) appendConstsChunk(additionalPropertiesArgs.consts.join("\n"));
+				current = {
+					expr: zodMiniCall("record", `${zodMiniCall("string")}, ${rendered.expr}`),
+					kind: "object"
+				};
+				continue;
+			}
+			if (fn === "object" || fn === "strictObject" || fn === "looseObject") {
+				current = renderObject(args, fn === "looseObject" ? "looseObject" : getObjectFunctionName(true, strict));
+				continue;
+			}
+			if (fn === "passthrough" || fn === "strict") continue;
+			if (fn === "array") {
+				const arrayArgs = args;
+				const rendered = renderMiniDefinition(arrayArgs, fieldPath);
+				if (isString(arrayArgs.consts)) appendConstsChunk(arrayArgs.consts);
+				else if (Array.isArray(arrayArgs.consts)) appendConstsChunk(arrayArgs.consts.join("\n"));
+				current = {
+					expr: zodMiniCall("array", rendered.expr),
+					kind: "array"
+				};
+				continue;
+			}
+			if (fn === "tuple") {
+				const tupleItems = args.map((x) => {
+					const rendered = renderMiniDefinition(x, fieldPath);
+					appendConstsChunk(x.consts.join("\n"));
+					return rendered.expr;
+				}).join(",\n");
+				const next = definition.functions[index + 1];
+				if (next?.[0] === "rest") {
+					const restDefinition = next[1];
+					const rest = renderMiniDefinition(restDefinition, fieldPath).expr;
+					appendConstsChunk(restDefinition.consts.join("\n"));
+					current = {
+						expr: zodMiniCall("tuple", `[${tupleItems}], ${rest}`),
+						kind: "tuple"
+					};
+					index++;
+				} else current = {
+					expr: zodMiniCall("tuple", `[${tupleItems}]`),
+					kind: "tuple"
+				};
+				continue;
+			}
+			const combinedArgs = buildCombinedArgs(fn, args, fieldPath);
+			if (fn === "optional" || fn === "nullable" || fn === "nullish") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: zodMiniCall(fn, value.expr),
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "default") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: zodMiniCall("_default", `${value.expr}, ${combinedArgs}`),
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "describe" || fn === "meta") {
+				const value = requireCurrent(fn);
+				current = {
+					expr: `${value.expr}.check(${zodMiniCall(fn, combinedArgs)})`,
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "min" || fn === "max" || fn === "gt" || fn === "lt" || fn === "multipleOf" || fn === "regex" || fn === "length") {
+				const value = requireCurrent(fn);
+				const checkName = fn === "min" ? value.kind === "number" ? "gte" : "minLength" : fn === "max" ? value.kind === "number" ? "lte" : "maxLength" : fn;
+				current = {
+					expr: `${value.expr}.check(${zodMiniCall(checkName, combinedArgs)})`,
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn !== "date" && shouldCoerce(fn) || fn === "date" && shouldCoerce(fn) && context.output.override.useDates) {
+				current = {
+					expr: zodMiniCoerceCall(fn, combinedArgs),
+					kind: fn
+				};
+				continue;
+			}
+			current = {
+				expr: zodMiniCall(fn, combinedArgs),
+				kind: fn === "enum" || fn === "literal" || fn === "stringFormat" ? "string" : fn.split(".")[0]
+			};
+		}
+		return current ?? { expr: "" };
+	};
+	function mergeAllOfObjectsClassic(allOfArgs, fieldPath) {
+		if (!(allOfArgs.length > 0 && allOfArgs.every((partSchema) => {
+			if (partSchema.functions.length === 0) return false;
+			const firstFn = partSchema.functions[0][0];
+			return firstFn === "object" || firstFn === "strictObject";
+		}))) return null;
+		const mergedProperties = {};
+		let allConsts = "";
+		for (const partSchema of allOfArgs) {
+			if (partSchema.consts.length > 0) allConsts += partSchema.consts.join("\n");
+			const objectFunctionIndex = partSchema.functions.findIndex(([fnName]) => fnName === "object" || fnName === "strictObject");
+			if (objectFunctionIndex !== -1) {
+				const objectArgs = partSchema.functions[objectFunctionIndex][1];
+				if (isObject(objectArgs)) Object.assign(mergedProperties, objectArgs);
+			}
+		}
+		if (allConsts.length > 0) appendConstsChunk(allConsts);
+		const mergedObjectString = `zod.${getObjectFunctionName(isZodV4, strict)}({
+${Object.entries(mergedProperties).map(([key, schema]) => {
+			const value = schema.functions.map((prop) => parseProperty(prop, [...fieldPath, key])).join("");
+			appendConstsChunk(schema.consts.join("\n"));
+			return `  ${JSON.stringify(key)}: ${value.startsWith(".") ? "zod" : ""}${value}`;
+		}).join(",\n")}
+})`;
+		if (strict && !isZodV4) return `${mergedObjectString}.strict()`;
+		return mergedObjectString;
+	}
+	const renderDiscriminatedUnionMember = (member, fieldPath) => {
+		if (member.functions[0]?.[0] === "allOf") {
+			const merged = mergeAllOfObjectsClassic(member.functions[0][1], fieldPath);
+			if (merged !== null) return merged;
+		}
+		appendConstsChunk(member.consts.join("\n"));
+		const value = member.functions.map((prop) => parseProperty(prop, fieldPath)).join("");
+		return `${value.startsWith(".") ? "zod" : ""}${value}`;
+	};
 	const parseProperty = (property, fieldPath = []) => {
 		const [fn, args = ""] = property;
 		if (fn === "namedRef") {
@@ -579,31 +930,9 @@ const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false,
 		if (fn === "fileOrString") return "zod.instanceof(File).or(zod.string())";
 		if (fn === "allOf") {
 			const allOfArgs = args;
-			if (strict && allOfArgs.length > 0 && allOfArgs.every((partSchema) => {
-				if (partSchema.functions.length === 0) return false;
-				const firstFn = partSchema.functions[0][0];
-				return firstFn === "object" || firstFn === "strictObject";
-			})) {
-				const mergedProperties = {};
-				let allConsts = "";
-				for (const partSchema of allOfArgs) {
-					if (partSchema.consts.length > 0) allConsts += partSchema.consts.join("\n");
-					const objectFunctionIndex = partSchema.functions.findIndex(([fnName]) => fnName === "object" || fnName === "strictObject");
-					if (objectFunctionIndex !== -1) {
-						const objectArgs = partSchema.functions[objectFunctionIndex][1];
-						if (isObject(objectArgs)) Object.assign(mergedProperties, objectArgs);
-					}
-				}
-				if (allConsts.length > 0) appendConstsChunk(allConsts);
-				const mergedObjectString = `zod.${getObjectFunctionName(isZodV4, strict)}({
-${Object.entries(mergedProperties).map(([key, schema]) => {
-					const value = schema.functions.map((prop) => parseProperty(prop, [...fieldPath, key])).join("");
-					appendConstsChunk(schema.consts.join("\n"));
-					return `  "${key}": ${value.startsWith(".") ? "zod" : ""}${value}`;
-				}).join(",\n")}
-})`;
-				if (!isZodV4) return `${mergedObjectString}.strict()`;
-				return mergedObjectString;
+			if (strict) {
+				const merged = mergeAllOfObjectsClassic(allOfArgs, fieldPath);
+				if (merged !== null) return merged;
 			}
 			let acc = "";
 			for (const partSchema of allOfArgs) {
@@ -615,12 +944,17 @@ ${Object.entries(mergedProperties).map(([key, schema]) => {
 			}
 			return acc;
 		}
-		if (fn === "oneOf" || fn === "anyOf") {
+		const discriminator = decodeDiscriminatorSeparator(fn);
+		if (discriminator || fn === "oneOf" || fn === "anyOf") {
 			const unionArgs = args;
 			if (unionArgs.length === 1) {
 				appendConstsChunk(unionArgs[0].consts.join("\n"));
 				return unionArgs[0].functions.map((prop) => parseProperty(prop, fieldPath)).join("");
 			}
+			if (discriminator) {
+				const members = unionArgs.map((member) => renderDiscriminatedUnionMember(member, fieldPath));
+				return `.discriminatedUnion('${jsStringEscape(discriminator.property)}', [${members.join(",")}])`;
+			}
 			return `.union([${unionArgs.map(({ functions, consts: argConsts }) => {
 				const value = functions.map((prop) => parseProperty(prop, fieldPath)).join("");
 				const valueWithZod = `${value.startsWith(".") ? "zod" : ""}${value}`;
@@ -642,8 +976,8 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 				const value = schema.functions.map((prop) => parseProperty(prop, [...fieldPath, key])).join("");
 				appendConstsChunk(schema.consts.join("\n"));
 				const fieldZod = `${value.startsWith(".") ? "zod" : ""}${value}`;
-				if (Array.isArray(coerceTypes) && coerceTypes.includes("array") && schema.functions.some(([fn]) => fn === "array")) return `  "${key}": zod.preprocess((value) => value === undefined || Array.isArray(value) ? value : [value], ${fieldZod})`;
-				return `  "${key}": ${fieldZod}`;
+				if (Array.isArray(coerceTypes) && coerceTypes.includes("array") && schema.functions.some(([fn]) => fn === "array")) return `  ${JSON.stringify(key)}: zod.preprocess((value) => value === undefined || Array.isArray(value) ? value : [value], ${fieldZod})`;
+				return `  ${JSON.stringify(key)}: ${fieldZod}`;
 			}).join(",\n")}
 })`;
 			if (fn === "looseObject" && !isZodV4) return `${parsedObject}.passthrough()`;
@@ -674,6 +1008,16 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 		return `.${fn}(${combinedArgs})`;
 	};
 	appendConstsChunk(input.consts.join("\n"));
+	if (variant === "mini") {
+		const rendered = renderMiniDefinition(input);
+		const value = preprocess ? zodMiniCall("pipe", `${zodMiniCall("transform", preprocess.name)}, ${rendered.expr}`) : rendered.expr;
+		if (consts.includes(",export")) consts = consts.replaceAll(",export", "\nexport");
+		return {
+			zod: value,
+			consts,
+			usedRefs
+		};
+	}
 	const schema = input.functions.map((prop) => parseProperty(prop)).join("");
 	const value = preprocess ? `.preprocess(${preprocess.name}, ${schema.startsWith(".") ? "zod" : ""}${schema})` : schema;
 	const zod = `${value.startsWith(".") ? "zod" : ""}${value}`;
@@ -827,6 +1171,15 @@ const generateFormDataZodSchema = (schema, context, name, strict, isZodV4, encod
 		useReusableSchemas
 	});
 };
+/**
+* Parse a request body or response into a zod validation schema definition.
+*
+* Selects the relevant content type — JSON (and `+json` vendor types),
+* `multipart/form-data`, or `application/x-www-form-urlencoded`, plus
+* `text/plain` for responses — and generates the matching schema, handling
+* array roots. The url-encoded string-contract rationale lives where the flag
+* is derived (see `isFormUrlEncoded` below).
+*/
 const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4, parseType, useReusableSchemas }) => {
 	if (!data || !generate) return {
 		input: {
@@ -839,7 +1192,9 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 	const contentEntries = Object.entries(resolvedRef.content ?? {});
 	const jsonContent = contentEntries.find(isMediaType(String.raw`^application\/([^/;]+\+)?json$`));
 	const formDataContent = contentEntries.find(isMediaType(String.raw`^multipart\/form-data$`));
-	const [contentType, mediaType] = jsonContent ? ["application/json", jsonContent[1]] : formDataContent ? ["multipart/form-data", formDataContent[1]] : [void 0, void 0];
+	const formUrlEncodedContent = contentEntries.find(isMediaType(String.raw`^application\/x-www-form-urlencoded$`));
+	const [contentType, mediaType] = jsonContent ? ["application/json", jsonContent[1]] : formDataContent ? ["multipart/form-data", formDataContent[1]] : formUrlEncodedContent ? ["application/x-www-form-urlencoded", formUrlEncodedContent[1]] : [void 0, void 0];
+	const isFormUrlEncoded = contentType === "application/x-www-form-urlencoded";
 	const schema = mediaType?.schema;
 	if (!schema) {
 		if (parseType === "response") {
@@ -870,7 +1225,8 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 		return {
 			input: generateZodValidationSchemaDefinition(parseType === "body" ? removeReadOnlyProperties(rawItems) : rawItems, context, name, strict, isZodV4, {
 				required: true,
-				useReusableSchemas
+				useReusableSchemas,
+				urlEncoded: isFormUrlEncoded
 			}),
 			isArray: true,
 			rules: {
@@ -883,7 +1239,8 @@ const parseBodyAndResponse = ({ data, context, name, strict, generate, isZodV4,
 	return {
 		input: contentType === "multipart/form-data" ? generateFormDataZodSchema(effectiveSchema, context, name, strict, isZodV4, encoding, useReusableSchemas) : generateZodValidationSchemaDefinition(effectiveSchema, context, name, strict, isZodV4, {
 			required: true,
-			useReusableSchemas
+			useReusableSchemas,
+			urlEncoded: isFormUrlEncoded
 		}),
 		isArray: false
 	};
@@ -990,8 +1347,13 @@ const parseParameters = ({ data, context, operationName, isZodV4, strict, genera
 		params
 	};
 };
-const generateZodRoute = async ({ operationId, operationName, verb, override }, { pathRoute, context, output }) => {
+const generateZodRoute = async ({ operationId, operationName, typeName, verb, override }, { pathRoute, context, output }) => {
+	const zodVariant = context.output.override.zod.variant;
 	const isZodV4 = resolveIsZodV4(context.output.override.zod.version, context.output.packageJson);
+	assertZodTarget({
+		variant: zodVariant,
+		isZodV4
+	});
 	const useReusableSchemas = context.output.override.zod.generateReusableSchemas;
 	const spec = context.spec.paths?.[pathRoute];
 	if (spec == void 0) throw new Error(`No such path ${pathRoute} in ${context.projectName}`);
@@ -1040,14 +1402,14 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	const pascalOperationName = pascal(operationName);
+	const pascalTypeName = pascal(typeName);
 	const makeParamsInjection = (location, schemaSuffix) => paramsMutator ? {
 		mutator: paramsMutator,
 		operationId,
 		location,
-		schemaName: `${pascalOperationName}${schemaSuffix}`
+		schemaName: `${pascalTypeName}${schemaSuffix}`
 	} : void 0;
-	let inputParams = parseZodValidationSchemaDefinition(parsedParameters.params, context, override.zod.coerce.param, override.zod.strict.param, isZodV4, preprocessParams, makeParamsInjection("param", "Params"));
+	let inputParams = parseZodValidationSchemaDefinition(parsedParameters.params, context, override.zod.coerce.param, override.zod.strict.param, isZodV4, preprocessParams, makeParamsInjection("param", "Params"), zodVariant);
 	const preprocessQueryParams = override.zod.preprocess?.query ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.query,
@@ -1055,7 +1417,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputQueryParams = parseZodValidationSchemaDefinition(parsedParameters.queryParams, context, override.zod.coerce.query, override.zod.strict.query, isZodV4, preprocessQueryParams, makeParamsInjection("query", "QueryParams"));
+	let inputQueryParams = parseZodValidationSchemaDefinition(parsedParameters.queryParams, context, override.zod.coerce.query, override.zod.strict.query, isZodV4, preprocessQueryParams, makeParamsInjection("query", "QueryParams"), zodVariant);
 	const preprocessHeader = override.zod.preprocess?.header ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.header,
@@ -1063,7 +1425,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputHeaders = parseZodValidationSchemaDefinition(parsedParameters.headers, context, override.zod.coerce.header, override.zod.strict.header, isZodV4, preprocessHeader, makeParamsInjection("header", "Header"));
+	let inputHeaders = parseZodValidationSchemaDefinition(parsedParameters.headers, context, override.zod.coerce.header, override.zod.strict.header, isZodV4, preprocessHeader, makeParamsInjection("header", "Header"), zodVariant);
 	const preprocessBody = override.zod.preprocess?.body ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.body,
@@ -1071,7 +1433,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	let inputBody = parseZodValidationSchemaDefinition(parsedBody.input, context, override.zod.coerce.body, override.zod.strict.body, isZodV4, preprocessBody, makeParamsInjection("body", "Body"));
+	let inputBody = parseZodValidationSchemaDefinition(parsedBody.input, context, override.zod.coerce.body, override.zod.strict.body, isZodV4, preprocessBody, makeParamsInjection("body", "Body"), zodVariant);
 	const preprocessResponse = override.zod.preprocess?.response ? await generateMutator({
 		output,
 		mutator: override.zod.preprocess.response,
@@ -1079,7 +1441,7 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		workspace: context.workspace,
 		tsconfig: context.output.tsconfig
 	}) : void 0;
-	const inputResponses = parsedResponses.map((parsedResponse, index) => parseZodValidationSchemaDefinition(parsedResponse.input, context, override.zod.coerce.response, override.zod.strict.response, isZodV4, preprocessResponse, makeParamsInjection("response", responses[index][0] ? `${responses[index][0]}Response` : "Response")));
+	const inputResponses = parsedResponses.map((parsedResponse, index) => parseZodValidationSchemaDefinition(parsedResponse.input, context, override.zod.coerce.response, override.zod.strict.response, isZodV4, preprocessResponse, makeParamsInjection("response", responses[index][0] ? `${responses[index][0]}Response` : "Response"), zodVariant));
 	const SENTINEL_PATTERN = /__REF_([A-Za-z_$][A-Za-z0-9_$]*)__/g;
 	const rewriteSentinels = (s) => s.replaceAll(SENTINEL_PATTERN, (_m, name) => name);
 	const allUsedRefs = new Set([
@@ -1118,6 +1480,11 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 	};
 	const useBrandedTypes = override.zod.useBrandedTypes;
 	const brand = (name) => useBrandedTypes ? isZodV4 ? `.brand("${name}")` : `.brand<"${name}">()` : "";
+	const zodArrayWithBounds = (itemName, rules) => {
+		const checks = [...rules?.min ? [zodMiniCall("minLength", `${rules.min}`)] : [], ...rules?.max ? [zodMiniCall("maxLength", `${rules.max}`)] : []];
+		if (zodVariant === "mini") return `${zodMiniCall("array", itemName)}${checks.map((check) => `.check(${check})`).join("")}`;
+		return `zod.array(${itemName})${rules?.min ? `.min(${rules.min})` : ""}${rules?.max ? `.max(${rules.max})` : ""}`;
+	};
 	const localTaken = new Set(allUsedRefs);
 	const allocateExportName = (baseName, hasItem) => {
 		const collides = (name) => localTaken.has(name) || hasItem && localTaken.has(`${name}Item`);
@@ -1138,10 +1505,10 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 		reserve(candidate);
 		return candidate;
 	};
-	const paramsName = allocateExportName(`${pascalOperationName}Params`, false);
-	const queryParamsName = allocateExportName(`${pascalOperationName}QueryParams`, false);
-	const headerName = allocateExportName(`${pascalOperationName}Header`, false);
-	const bodyName = allocateExportName(`${pascalOperationName}Body`, parsedBody.isArray);
+	const paramsName = allocateExportName(`${pascalTypeName}Params`, false);
+	const queryParamsName = allocateExportName(`${pascalTypeName}QueryParams`, false);
+	const headerName = allocateExportName(`${pascalTypeName}Header`, false);
+	const bodyName = allocateExportName(`${pascalTypeName}Body`, parsedBody.isArray);
 	return {
 		implementation: [
 			...inputParams.consts ? [inputParams.consts] : [],
@@ -1152,9 +1519,9 @@ const generateZodRoute = async ({ operationId, operationName, verb, override },
 			...inputHeaders.zod ? [`export const ${headerName} = ${inputHeaders.zod}${brand(headerName)}`] : [],
 			...inputBody.consts ? [inputBody.consts] : [],
 			...inputBody.zod ? [parsedBody.isArray ? `export const ${bodyName}Item = ${inputBody.zod}
-export const ${bodyName} = zod.array(${bodyName}Item)${parsedBody.rules?.min ? `.min(${parsedBody.rules.min})` : ""}${parsedBody.rules?.max ? `.max(${parsedBody.rules.max})` : ""}${brand(bodyName)}` : `export const ${bodyName} = ${inputBody.zod}${brand(bodyName)}`] : [],
+export const ${bodyName} = ${zodArrayWithBounds(bodyName + "Item", parsedBody.rules)}${brand(bodyName)}` : `export const ${bodyName} = ${inputBody.zod}${brand(bodyName)}`] : [],
 			...inputResponses.flatMap((inputResponse, index) => {
-				const operationResponse = allocateExportName(pascal(`${operationName}-${responses[index][0]}-response`), parsedResponses[index].isArray);
+				const operationResponse = allocateExportName(pascal(`${typeName}-${responses[index][0]}-response`), parsedResponses[index].isArray);
 				if (!inputResponse.zod) {
 					if (!override.zod.generate.response) return [];
 					const noContentStatusCodes = new Set(["204", "205"]);
@@ -1166,10 +1533,10 @@ export const ${bodyName} = zod.array(${bodyName}Item)${parsedBody.rules?.min ? `
 						const specResponseKeys = new Set(Object.keys(spec[verb]?.responses ?? {}));
 						isNoContent = !(specResponseKeys.has("200") || specResponseKeys.has("2XX") || specResponseKeys.has("2xx"));
 					}
-					return [`export const ${operationResponse} = ${isNoContent ? "zod.void()" : "zod.unknown()"}${brand(operationResponse)}`];
+					return [`export const ${operationResponse} = ${isNoContent ? zodVariant === "mini" ? zodMiniCall("void") : "zod.void()" : zodVariant === "mini" ? zodMiniCall("unknown") : "zod.unknown()"}${brand(operationResponse)}`];
 				}
 				return [...inputResponse.consts ? [inputResponse.consts] : [], parsedResponses[index].isArray ? `export const ${operationResponse}Item = ${inputResponse.zod}
-export const ${operationResponse} = zod.array(${operationResponse}Item)${parsedResponses[index].rules?.min ? `.min(${parsedResponses[index].rules.min})` : ""}${parsedResponses[index].rules?.max ? `.max(${parsedResponses[index].rules.max})` : ""}${brand(operationResponse)}` : `export const ${operationResponse} = ${inputResponse.zod}${brand(operationResponse)}`];
+export const ${operationResponse} = ${zodArrayWithBounds(`${operationResponse}Item`, parsedResponses[index].rules)}${brand(operationResponse)}` : `export const ${operationResponse} = ${inputResponse.zod}${brand(operationResponse)}`];
 			})
 		].join("\n\n"),
 		mutators: [
@@ -1201,6 +1568,6 @@ const zodClientBuilder = {
 };
 const builder = () => () => zodClientBuilder;
 //#endregion
-export { builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
+export { assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
 
 //# sourceMappingURL=index.mjs.map