@orval/zod 8.24.0 → 8.26.0

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import { ClientBuilder, ClientDependenciesBuilder, ClientGeneratorsBuilder, ContextSpec, GeneratorMutator, OpenApiParameterObject, OpenApiReferenceObject, OpenApiSchemaObject, PackageJson, ZodCoerceType, ZodVariantOption, ZodVersionOption } from "@orval/core";
-
 //#region src/compatible-v4.d.ts
 declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
 /**
@@ -13,10 +12,7 @@ declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
  * target is pinned while preserving package-detection for `'auto'`.
  */
 declare const resolveIsZodV4: (version: ZodVersionOption | undefined, packageJson: PackageJson | undefined) => boolean;
-declare const assertZodTarget: ({
-  variant,
-  isZodV4
-}: {
+declare const assertZodTarget: ({ variant, isZodV4 }: {
   variant: ZodVariantOption | undefined;
   isZodV4: boolean;
 }) => void;
@@ -104,6 +100,12 @@ interface ZodParamsContext {
 interface ZodParamsInjection extends Pick<ZodParamsContext, 'operationId' | 'location' | 'schemaName'> {
   mutator: GeneratorMutator;
 }
+interface ZodMetaArgs {
+  id?: string;
+  title?: string;
+  description?: string;
+  deprecated?: boolean;
+}
 declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDefinition, context: ContextSpec, coerceTypes: boolean | ZodCoerceType[] | undefined, strict: boolean, isZodV4: boolean, preprocess?: GeneratorMutator, paramsInjection?: ZodParamsInjection, variant?: ZodVariantOption, exactOptional?: boolean) => {
   zod: string;
   consts: string;
@@ -132,15 +134,7 @@ declare const dereference: (schema: OpenApiSchemaObject | OpenApiReferenceObject
 declare const generateFormDataZodSchema: (schema: OpenApiSchemaObject, context: ContextSpec, name: string, strict: boolean, isZodV4: boolean, encoding?: Record<string, {
   contentType?: string;
 }>, useReusableSchemas?: boolean) => ZodValidationSchemaDefinition;
-declare const parseParameters: ({
-  data,
-  context,
-  operationName,
-  isZodV4,
-  strict,
-  generate,
-  useReusableSchemas
-}: {
+declare const parseParameters: ({ data, context, operationName, isZodV4, strict, generate, useReusableSchemas }: {
   data: (OpenApiParameterObject | OpenApiReferenceObject)[] | undefined;
   context: ContextSpec;
   operationName: string;
@@ -168,5 +162,5 @@ declare const parseParameters: ({
 declare const generateZod: ClientBuilder;
 declare const builder: () => () => ClientGeneratorsBuilder;
 //#endregion
-export { ZodParamsContext, ZodParamsInjection, ZodValidationSchemaDefinition, assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
+export { ZodMetaArgs, ZodParamsContext, ZodParamsInjection, ZodValidationSchemaDefinition, assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, resolveIsZodV4 };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-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 { EnumGeneration, buildDynamicScope, buildInlineDynamicScope, camel, compareVersions, generateMutator, getDynamicAnchorName, getEnumImplementation, getEnumMembers, getEnumValueInfo, getFormDataFieldFileType, getNumberWord, getRefInfo, getRequiredKeys, hasEnumMetadata, 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
@@ -73,7 +73,7 @@ const getZodDependencies = (_hasGlobalMutator, _hasParamsSerializerOptions, _pac
 /**
 * values that may appear in "type". Equals SchemaObjectType
 */
-const possibleSchemaTypes = new Set([
+const possibleSchemaTypes = /* @__PURE__ */ new Set([
 	"integer",
 	"number",
 	"string",
@@ -83,7 +83,7 @@ const possibleSchemaTypes = new Set([
 	"null",
 	"array"
 ]);
-const predefinedZodFormats = new Set([
+const predefinedZodFormats = /* @__PURE__ */ new Set([
 	"date",
 	"time",
 	"date-time",
@@ -112,7 +112,7 @@ const resolveZodType = (schema) => {
 	}
 	return type ?? "unknown";
 };
-const COERCIBLE_TYPES = new Set([
+const COERCIBLE_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"number",
 	"boolean",
@@ -122,6 +122,12 @@ const COERCIBLE_TYPES = new Set([
 const PURE_COMMENT = "/*#__PURE__*/ ";
 const zodMiniCall = (fn, args = "") => `${PURE_COMMENT}zod.${fn}(${args})`;
 const zodMiniCoerceCall = (fn, args = "") => `${PURE_COMMENT}zod.coerce.${fn}(${args})`;
+const hasUnicodePropertyEscape = (pattern) => /(^|[^\\])(?:\\\\)*\\[pP]\{/.test(pattern);
+const buildRegExpLiteral = (pattern) => {
+	const innerPattern = pattern.slice(pattern.startsWith("/") ? 1 : 0, pattern.endsWith("/") ? -1 : void 0);
+	const unicodeFlag = hasUnicodePropertyEscape(innerPattern) ? ", 'u'" : "";
+	return `new RegExp('${jsStringLiteralEscape(innerPattern)}'${unicodeFlag})`;
+};
 /** Escapes string defaults for safe embedding in template literals. */
 function formatDefaultValue(value) {
 	if (isString(value)) return jsesc(value, {
@@ -134,7 +140,7 @@ function formatDefaultValue(value) {
 	}) : formatDefaultValue(item)).join(", ")}]`;
 	return stringify(value) ?? "null";
 }
-const minAndMaxTypes = new Set([
+const minAndMaxTypes = /* @__PURE__ */ new Set([
 	"number",
 	"integer",
 	"string",
@@ -178,7 +184,7 @@ 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 SHAPELESS_MEMBER_KEYS = new Set([
+const SHAPELESS_MEMBER_KEYS = /* @__PURE__ */ new Set([
 	"required",
 	"title",
 	"description",
@@ -190,6 +196,14 @@ const isConstraintOnlyMember = (member) => {
 	if (!Array.isArray(schema.required) || schema.required.length === 0) return false;
 	return Object.keys(schema).every((key) => SHAPELESS_MEMBER_KEYS.has(key));
 };
+const getForbiddenKeys = (member) => {
+	if (!isObject(member.not)) return void 0;
+	const not = member.not;
+	const branches = Array.isArray(not.anyOf) ? not.anyOf : Array.isArray(not.required) ? [not] : [];
+	const forbidden = /* @__PURE__ */ new Set();
+	for (const branch of branches) if (isObject(branch) && Array.isArray(branch.required)) for (const key of branch.required) forbidden.add(key);
+	return forbidden.size > 0 ? [...forbidden] : void 0;
+};
 const hasLiteralDiscriminator = (schema, property) => {
 	if (!schema || !isObject(schema.properties)) return false;
 	const propertySchema = schema.properties[property];
@@ -237,7 +251,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		functions: [],
 		consts: []
 	};
-	const CHAINABLE_SIBLINGS = new Set([
+	const CHAINABLE_SIBLINGS = /* @__PURE__ */ new Set([
 		"nullable",
 		"default",
 		"description"
@@ -313,11 +327,19 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 	const pushDescriptionOrMeta = () => {
 		const description = typeof schema.description === "string" && schema.description.length > 0 ? schema.description : void 0;
 		const deprecated = "deprecated" in schema && schema.deprecated === true ? true : void 0;
+		const title = typeof schema.title === "string" && schema.title.length > 0 ? schema.title : void 0;
+		const isAnnotatedConst = schema.const !== void 0 && (title !== void 0 || deprecated === true);
 		if (rules?.emitMeta && isZodV4) {
 			const meta = { id: name };
 			if (description !== void 0) meta.description = description;
 			if (deprecated) meta.deprecated = true;
 			functions.push(["meta", meta]);
+		} else if (isZodV4 && isAnnotatedConst) {
+			const meta = {};
+			if (title !== void 0) meta.title = title;
+			if (description !== void 0) meta.description = description;
+			if (deprecated) meta.deprecated = true;
+			functions.push(["meta", meta]);
 		} else if (description !== void 0) functions.push(["describe", `'${jsStringEscape(description)}'`]);
 	};
 	const type = resolveZodType(schema);
@@ -354,25 +376,41 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			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 : [];
+		const allOfRequired = schema.allOf ? [.../* @__PURE__ */ new Set([...getRequiredKeys(schema, name), ...schemas.flatMap((member, index) => {
+			const isRef = "$ref" in member && typeof member.$ref === "string";
+			const resolved = isRef ? tryResolveRefSchema(member.$ref, context) : member;
+			if (!resolved) return [];
+			return getRequiredKeys(resolved, isRef ? member.$ref : `${name}.allOf[${index}]`);
 		})])] : void 0;
 		const withSiblingProperties = (member) => {
 			const properties = schema.properties;
 			if (!(schema.oneOf || schema.anyOf) || !isObject(properties) || Object.keys(properties).length === 0 || !isConstraintOnlyMember(member)) return member;
 			const required = member.required;
 			if (!required.every((key) => Object.hasOwn(properties, key))) return member;
+			const forbidden = getForbiddenKeys(member);
+			let propertyOverrides;
+			if (forbidden) {
+				propertyOverrides = {};
+				for (const key of forbidden) {
+					const isForbiddenAndRequired = required.includes(key);
+					propertyOverrides[key] = {
+						functions: [["never", void 0], ...isForbiddenAndRequired ? [] : [["optional", void 0]]],
+						consts: []
+					};
+				}
+			}
 			return {
 				type: "object",
 				properties,
 				required,
-				description: member.description
+				description: member.description,
+				"x-orval-property-overrides": propertyOverrides
 			};
 		};
 		const baseSchemas = schemas.map((schema, index) => generateZodValidationSchemaDefinition(withSiblingProperties(schema), context, `${camel(name)}${pascal(getNumberWord(index + 1))}`, strict, isZodV4, {
 			required: true,
 			additionalRequired: allOfRequired,
+			propertyOverrides: withSiblingProperties(schema)["x-orval-property-overrides"],
 			constNameRegistry,
 			useReusableSchemas,
 			urlEncoded
@@ -507,9 +545,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				if (!predefinedZodFormats.has(schema.format ?? "")) {
 					if ("const" in schema) functions.push(["literal", JSON.stringify(String(schema.const))]);
 					else if (schema.pattern && schema.format) {
-						const isStartWithSlash = schema.pattern.startsWith("/");
-						const isEndWithSlash = schema.pattern.endsWith("/");
-						const regexp = `new RegExp('${jsStringLiteralEscape(schema.pattern.slice(isStartWithSlash ? 1 : 0, isEndWithSlash ? -1 : void 0))}')`;
+						const regexp = buildRegExpLiteral(schema.pattern);
 						consts.push(`export const ${name}RegExp${constsCounterValue} = ${regexp};\n`);
 						functions.push(["stringFormat", [`'${jsStringLiteralEscape(schema.format)}'`, `${name}RegExp${constsCounterValue}`]]);
 					} else functions.push([type, void 0]);
@@ -552,6 +588,10 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 				break;
 			}
 			break;
+		case "never":
+			functions.push(["never", void 0]);
+			if (required) functions.push(["optional", void 0]);
+			break;
 		default: {
 			if ("const" in schema) {
 				const constValue = schema.const;
@@ -567,7 +607,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 			const shouldUseLooseObject = type === "object" && !hasDefinedProperties && schema.additionalProperties === void 0 && !hasAdditionalPropertiesSchema;
 			if (hasProperties && hasDefinedProperties) {
 				const objectType = getObjectFunctionName(isZodV4, strict);
-				const requiredKeys = new Set([...schema.required ?? [], ...rules?.additionalRequired ?? []]);
+				const requiredKeys = /* @__PURE__ */ new Set([...getRequiredKeys(schema, name), ...rules?.additionalRequired ?? []]);
 				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,
@@ -606,10 +646,12 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		if (shouldUseExclusiveMin && exclusiveMin !== void 0) {
 			consts.push(`export const ${name}ExclusiveMin${constsCounterValue} = ${exclusiveMin};`);
 			functions.push(["gt", `${name}ExclusiveMin${constsCounterValue}`]);
-		} else if (min !== void 0) if (min === 1) functions.push(["min", `${min}`]);
-		else {
-			consts.push(`export const ${name}Min${constsCounterValue} = ${min};`);
-			functions.push(["min", `${name}Min${constsCounterValue}`]);
+		} else if (min !== void 0) {
+			if (min === 1) functions.push(["min", `${min}`]);
+			else {
+				consts.push(`export const ${name}Min${constsCounterValue} = ${min};`);
+				functions.push(["min", `${name}Min${constsCounterValue}`]);
+			}
 		}
 		if (shouldUseExclusiveMax && exclusiveMax !== void 0) {
 			consts.push(`export const ${name}ExclusiveMax${constsCounterValue} = ${exclusiveMax};`);
@@ -626,18 +668,25 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 	}
 	const stringFormatAlreadyEmitted = isZodV4 && type === "string" && !!matches && !!schema.format && !predefinedZodFormats.has(schema.format ?? "");
 	if (matches && !hasNonArrayEnum && type === "string" && !stringFormatAlreadyEmitted) {
-		const isStartWithSlash = matches.startsWith("/");
-		const isEndWithSlash = matches.endsWith("/");
-		const regexp = `new RegExp('${jsStringLiteralEscape(matches.slice(isStartWithSlash ? 1 : 0, isEndWithSlash ? -1 : void 0))}')`;
+		const regexp = buildRegExpLiteral(matches);
 		consts.push(`export const ${name}RegExp${constsCounterValue} = ${regexp};\n`);
 		if (schema.format && !predefinedZodFormats.has(schema.format) && isZodV4) functions.push(["stringFormat", [`'${jsStringLiteralEscape(schema.format)}'`, `${name}RegExp${constsCounterValue}`]]);
 		else functions.push(["regex", `${name}RegExp${constsCounterValue}`]);
 	}
 	if (schema.enum && type !== "array") {
-		const uniqueEnumValues = unique(schema.enum);
-		if (uniqueEnumValues.every((value) => isString(value))) functions.push(["enum", `[${uniqueEnumValues.map((value) => `'${jsStringLiteralEscape(value)}'`).join(", ")}]`]);
-		else functions.push(["oneOf", uniqueEnumValues.map((value) => ({
-			functions: [["literal", isString(value) ? `'${jsStringLiteralEscape(value)}'` : value]],
+		const enumMembers = getEnumMembers(schema);
+		const hasMetadata = hasEnumMetadata(enumMembers);
+		const enumValueInfo = getEnumValueInfo(enumMembers);
+		const enumValues = enumMembers.map((member) => member.value);
+		if (enumValueInfo.isHomogeneous && !enumValueInfo.isBoolean && hasMetadata) {
+			const enumContent = getEnumImplementation(enumMembers, {
+				enumNamingConvention: context.output.override.namingConvention.enum,
+				enumGenerationType: EnumGeneration.CONST
+			});
+			functions.push(["enumObject", `{\n${enumContent}}`]);
+		} else if (enumValues.every((value) => isString(value))) functions.push(["enum", `[${enumValues.map((value) => `'${jsStringLiteralEscape(value)}'`).join(", ")}]`]);
+		else functions.push(["oneOf", enumMembers.map((member) => ({
+			functions: [["literal", isString(member.value) ? `'${jsStringLiteralEscape(member.value)}'` : member.value]],
 			consts: []
 		}))]);
 	}
@@ -651,7 +700,7 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		consts: unique(consts)
 	};
 };
-const PARAMS_MODIFIER_VALIDATORS = new Set([
+const PARAMS_MODIFIER_VALIDATORS = /* @__PURE__ */ new Set([
 	"optional",
 	"nullable",
 	"nullish",
@@ -664,12 +713,20 @@ const PARAMS_MODIFIER_VALIDATORS = new Set([
 	"undefined",
 	"void"
 ]);
-const PARAMS_MERGE_INTO_OPTIONS_VALIDATORS = new Set([
+const PARAMS_MERGE_INTO_OPTIONS_VALIDATORS = /* @__PURE__ */ new Set([
 	"datetime",
 	"time",
 	"iso.datetime",
 	"iso.time"
 ]);
+const buildMetaArgs = (args) => {
+	const parts = [];
+	if (args.id !== void 0) parts.push(`id: '${jsStringEscape(args.id)}'`);
+	if (args.title !== void 0) parts.push(`title: '${jsStringEscape(args.title)}'`);
+	if (args.description !== void 0) parts.push(`description: '${jsStringEscape(args.description)}'`);
+	if (args.deprecated) parts.push("deprecated: true");
+	return parts.length > 0 ? `{ ${parts.join(", ")} }` : void 0;
+};
 const parseZodValidationSchemaDefinition = (input, context, coerceTypes = false, strict, isZodV4, preprocess, paramsInjection, variant = "classic", exactOptional = false) => {
 	if (input.functions.length === 0) return {
 		zod: "",
@@ -772,6 +829,13 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 				};
 				continue;
 			}
+			if (fn === "enumObject") {
+				current = {
+					expr: zodMiniCall("enum", `${String(args)} as const`),
+					kind: "enum"
+				};
+				continue;
+			}
 			if (fn === "allOf") {
 				const allOfArgs = args;
 				const mergedProperties = strict ? mergeAllOfObjectsMini(allOfArgs) : null;
@@ -867,8 +931,9 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 			}
 			const combinedArgs = buildCombinedArgs(fn, args, fieldPath);
 			if (fn === "int" && shouldCoerce("number")) {
+				const numberArgs = buildCombinedArgs("number", void 0, fieldPath);
 				current = {
-					expr: zodMiniCall("pipe", `${zodMiniCoerceCall("number", buildCombinedArgs("number", void 0, fieldPath))}, ${zodMiniCall("int", combinedArgs)}`),
+					expr: zodMiniCall("pipe", `${zodMiniCoerceCall("number", numberArgs)}, ${zodMiniCall("int", combinedArgs)}`),
 					kind: "number"
 				};
 				continue;
@@ -889,7 +954,16 @@ ${Object.entries(objectArgs).map(([key, schema]) => {
 				};
 				continue;
 			}
-			if (fn === "describe" || fn === "meta") {
+			if (fn === "meta") {
+				const value = requireCurrent(fn);
+				const metaArgs = buildMetaArgs(args);
+				if (metaArgs) current = {
+					expr: `${value.expr}.check(${zodMiniCall(fn, metaArgs)})`,
+					kind: value.kind
+				};
+				continue;
+			}
+			if (fn === "describe") {
 				const value = requireCurrent(fn);
 				current = {
 					expr: `${value.expr}.check(${zodMiniCall(fn, combinedArgs)})`,
@@ -963,12 +1037,13 @@ ${Object.entries(mergedProperties).map(([key, schema]) => {
 			usedRefs.add(refArgs.name);
 			return `__REF_${refArgs.name}__`;
 		}
+		if (fn === "enumObject") {
+			const enumObjectImplementation = args;
+			return isZodV4 ? `.enum(${enumObjectImplementation})` : `.nativeEnum(${enumObjectImplementation} as const)`;
+		}
 		if (fn === "meta") {
-			const metaArgs = args;
-			const parts = [`id: '${jsStringEscape(metaArgs.id)}'`];
-			if (metaArgs.description !== void 0) parts.push(`description: '${jsStringEscape(metaArgs.description)}'`);
-			if (metaArgs.deprecated) parts.push("deprecated: true");
-			return `.meta({ ${parts.join(", ")} })`;
+			const metaArgs = buildMetaArgs(args);
+			return metaArgs ? `.meta(${metaArgs})` : "";
 		}
 		if (fn === "fileOrString") return "zod.instanceof(File).or(zod.string())";
 		if (fn === "allOf") {
@@ -1315,6 +1390,12 @@ const parseParameters = ({ data, context, operationName, isZodV4, strict, genera
 			consts: []
 		}
 	};
+	const initialDefinitionsByParameters = {
+		headers: {},
+		queryParams: {},
+		params: {}
+	};
+	const constNameRegistry = {};
 	const defintionsByParameters = data.reduce((acc, val) => {
 		const { schema: parameter } = resolveRef(val, context);
 		if (!parameter.schema) return acc;
@@ -1337,7 +1418,8 @@ const parseParameters = ({ data, context, operationName, isZodV4, strict, genera
 		if (parameter.in !== "path" && parameter.in !== "query" && parameter.in !== "header") return acc;
 		const definition = generateZodValidationSchemaDefinition(schemaForGen, context, camel(`${operationName}-${parameter.in}-${parameter.name}`), mapStrict[parameter.in], isZodV4, {
 			required: parameter.required,
-			useReusableSchemas
+			useReusableSchemas,
+			constNameRegistry
 		});
 		if (parameter.in === "header" && mapGenerate.header) return {
 			...acc,
@@ -1361,11 +1443,7 @@ const parseParameters = ({ data, context, operationName, isZodV4, strict, genera
 			}
 		};
 		return acc;
-	}, {
-		headers: {},
-		queryParams: {},
-		params: {}
-	});
+	}, initialDefinitionsByParameters);
 	const headers = {
 		functions: [],
 		consts: []
@@ -1406,8 +1484,9 @@ const generateZodRoute = async ({ operationId, operationName, typeName, verb, ov
 	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}`);
+	const parameters = [...spec.parameters ?? [], ...spec[verb]?.parameters ?? []];
 	const parsedParameters = parseParameters({
-		data: [...spec.parameters ?? [], ...spec[verb]?.parameters ?? []],
+		data: parameters,
 		context,
 		operationName,
 		isZodV4,
@@ -1493,7 +1572,7 @@ const generateZodRoute = async ({ operationId, operationName, typeName, verb, ov
 	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, override.zod.exactOptional));
 	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([
+	const allUsedRefs = /* @__PURE__ */ new Set([
 		...inputParams.usedRefs,
 		...inputQueryParams.usedRefs,
 		...inputHeaders.usedRefs,
@@ -1573,7 +1652,7 @@ export const ${bodyName} = ${zodArrayWithBounds(bodyName + "Item", parsedBody.ru
 				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"]);
+					const noContentStatusCodes = /* @__PURE__ */ new Set(["204", "205"]);
 					const statusCode = responses[index][0];
 					const isEachHttpStatusMode = !!statusCode;
 					let isNoContent;