@kubb/plugin-zod 5.0.0-beta.98 → 5.0.0

package/dist/index.js

@@ -1,7 +1,180 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { Resolver, ast, containsCircularRef, createResolver, defineGenerator, definePlugin, extractRefName, syncSchemaRef } from "kubb/kit";
 import { Const, File, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
+function getOperationParameters(node) {
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
+}
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function buildOptionsSchema(node, resolver) {
+	const { path, query, header } = getOperationParameters(node);
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const createNever = () => ast.factory.createSchema({
+		type: "never",
+		primitive: void 0,
+		optional: true
+	});
+	const groups = [
+		{
+			name: "path",
+			params: path,
+			resolve: resolver.param.path
+		},
+		{
+			name: "query",
+			params: query,
+			resolve: resolver.param.query
+		},
+		{
+			name: "headers",
+			params: header,
+			resolve: resolver.param.headers
+		}
+	];
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? ast.factory.createSchema({
+					type: "ref",
+					name: resolve.call(resolver.param, node, params[0]),
+					optional: !required
+				}) : createNever()
+			});
+		})]
+	});
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+//#endregion
+//#region ../../internals/shared/src/adapter.ts
+/**
+* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
+* so OAS-only options (`dateType`, `enums`) and the parsed `document` are typed.
+*
+* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
+* clear, actionable error at the point of use.
+*
+* @example
+* ```ts
+* const { dateType } = getOasAdapter(ctx.adapter).options
+* ```
+*/
+function getOasAdapter(adapter) {
+	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
+	return adapter;
+}
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -346,106 +519,6 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
-//#region ../../internals/shared/src/params.ts
-const caseParamsCache = /* @__PURE__ */ new WeakMap();
-/**
-* Applies camelCase to parameter names and returns a new array without mutating the input.
-*
-* Run it before handing parameters to schema builders so output property keys get the right casing
-* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
-* original array is returned unchanged. Results are cached per input array.
-*/
-function caseParams(params, casing) {
-	if (!casing) return params;
-	const cached = caseParamsCache.get(params);
-	if (cached) return cached;
-	const result = params.map((param) => ({
-		...param,
-		name: camelCase(param.name)
-	}));
-	caseParamsCache.set(params, result);
-	return result;
-}
-//#endregion
-//#region ../../internals/shared/src/operation.ts
-/**
-* Maps a content type to the PascalCase suffix used to name per-content-type variants
-* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
-*/
-function getContentTypeSuffix(contentType) {
-	const baseType = contentType.split(";")[0].trim();
-	if (baseType === "application/json") return "Json";
-	if (baseType === "multipart/form-data") return "FormData";
-	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
-	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
-	if (parts.length === 0) return "Unknown";
-	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-/**
-* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
-* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
-*/
-function getPerContentTypeName(baseName, suffix) {
-	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
-	return baseName + suffix;
-}
-/**
-* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
-* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
-* the final (possibly counter-augmented) value, so callers can derive parallel names in another
-* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
-*/
-function resolveContentTypeVariants(entries, baseName) {
-	const usedNames = /* @__PURE__ */ new Set();
-	return entries.filter((entry) => entry.schema).map((entry) => {
-		const baseSuffix = getContentTypeSuffix(entry.contentType);
-		let suffix = baseSuffix;
-		let name = getPerContentTypeName(baseName, suffix);
-		let counter = 2;
-		while (usedNames.has(name)) {
-			suffix = `${baseSuffix}${counter++}`;
-			name = getPerContentTypeName(baseName, suffix);
-		}
-		usedNames.add(name);
-		return {
-			name,
-			suffix,
-			schema: entry.schema,
-			keysToOmit: entry.keysToOmit,
-			contentType: entry.contentType
-		};
-	});
-}
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
-function getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-//#endregion
-//#region ../../internals/shared/src/adapter.ts
-/**
-* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
-* so OAS-only options (`dateType`, `enums`) and the parsed `document` are typed.
-*
-* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
-* clear, actionable error at the point of use.
-*
-* @example
-* ```ts
-* const { dateType } = getOasAdapter(ctx.adapter).options
-* ```
-*/
-function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
-	return adapter;
-}
-//#endregion
 //#region ../../internals/shared/src/resolver.ts
 /**
 * Resolves a single operation parameter name with the
@@ -458,6 +531,29 @@ function operationParamName(node, param) {
 	return this.name(`${node.operationId} ${param.in} ${param.name}`);
 }
 /**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
 * Builds the shared `response` namespace. Spread the result into
 * `createResolver` and add plugin-specific methods (`options`, `error`) next
 * to it.
@@ -505,7 +601,7 @@ function createCasedFile(caseLast) {
 * `resolver.imports` would resolve file paths that are then discarded.
 */
 function collectRefNames(schema) {
-	return ast.collect(schema, { schema: (node) => {
+	return ast.collectSync(schema, { schema: (node) => {
 		const refNode = ast.narrowSchema(node, "ref");
 		if (!refNode?.ref) return null;
 		return ast.resolveRefName(refNode);
@@ -543,6 +639,45 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
+*/
+function mapSchemaMembers(node, transform) {
+	return (node.members ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+//#endregion
 //#region src/components/Zod.tsx
 function Zod({ name, node, printer, inferTypeName, cyclic }) {
 	const output = printer.print(node);
@@ -626,12 +761,12 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	if (hasCodec(node)) return true;
 	if (node.type === "ref") {
 		if (!node.ref) return false;
-		const refName = ast.extractRefName(node.ref);
+		const refName = extractRefName(node.ref);
 		if (refName) {
 			if (seen.has(refName)) return false;
 			seen.add(refName);
 		}
-		const resolved = ast.syncSchemaRef(node);
+		const resolved = syncSchemaRef(node);
 		if (resolved.type === "ref") return false;
 		return containsCodec(resolved, seen);
 	}
@@ -647,7 +782,7 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 * them to their input (encode) variant.
 */
 function collectCodecRefNames(node) {
-	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.resolveRefName(n) ?? void 0 : void 0 });
+	return ast.collectSync(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.resolveRefName(n) ?? void 0 : void 0 });
 }
 /**
 * Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
@@ -670,7 +805,7 @@ function isObjectSchemaNode(node, cyclicSchemas) {
 	if (node.type === "ref") {
 		const refName = ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return false;
-		const resolved = ast.syncSchemaRef(node);
+		const resolved = syncSchemaRef(node);
 		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
 	}
 	if (node.type === "union") {
@@ -746,6 +881,20 @@ function buildEnum(values) {
 	return `z.union([${literals.join(", ")}])`;
 }
 /**
+* Digit pattern for a `type: 'string'` schema that carries an integer `format`, the way ProtoJSON
+* encodes 64-bit integers. Returns `undefined` for every other format, and a `pattern` from the
+* spec takes precedence over this fallback.
+*
+* @example
+* ```ts
+* integerFormatPattern('uint64') // '^\\d+$'
+* ```
+*/
+function integerFormatPattern(format) {
+	if (format === "int32" || format === "int64") return "^-?\\d+$";
+	if (format === "uint64") return "^\\d+$";
+}
+/**
 * Map a `regexType` to the `func` argument of `toRegExpString`: `'constructor'` emits
 * `new RegExp(...)`, while `'literal'` (the default) emits a regex literal.
 */
@@ -870,6 +1019,22 @@ function applyMiniModifiers({ value, schema, nullable, optional, nullish, defaul
 	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
 	return literal !== null ? `z._default(${withModifier}, ${literal})` : withModifier;
 }
+/**
+* Builds an `object` schema node grouping the given parameter nodes.
+* The `primitive: 'object'` marker ensures the Zod printer emits `z.object(…)` rather than a record.
+*/
+function buildGroupedParamsSchema({ params, optional }) {
+	return ast.factory.createSchema({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: param.schema
+		}))
+	});
+}
 //#endregion
 //#region src/printers/printerZod.ts
 function strictOneOfMember$1(member, node, cyclicSchemas) {
@@ -878,7 +1043,7 @@ function strictOneOfMember$1(member, node, cyclicSchemas) {
 		if (member.startsWith("z.lazy(")) return member;
 		const refName = ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = ast.syncSchemaRef(node);
+		const schema = syncSchemaRef(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
 		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
@@ -903,8 +1068,8 @@ function getMemberConstraint({ member, regexType }) {
 function buildZodObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -913,7 +1078,7 @@ function buildZodObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = ast.syncSchemaRef(schema);
+		const meta = syncSchemaRef(schema);
 		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 		const value = applyModifiers({
 			value: baseOutput,
@@ -956,8 +1121,11 @@ const printerZod = ast.createPrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
-				return `${shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()"}${lengthConstraints({
+				const base = shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()";
+				const pattern = node.pattern ?? integerFormatPattern(node.format);
+				return `${base}${lengthConstraints({
 					...node,
+					pattern,
 					regexType: this.options.regexType
 				})}`;
 			},
@@ -1056,18 +1224,18 @@ const printerZod = ast.createPrinter((options) => {
 				})();
 			},
 			array(node) {
-				const base = `z.array(${ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
 					...node,
 					regexType: this.options.regexType
 				})}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = ast.mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
@@ -1098,7 +1266,7 @@ const printerZod = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1143,8 +1311,8 @@ function getMemberConstraintMini({ member, regexType }) {
 function buildZodMiniObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -1153,7 +1321,7 @@ function buildZodMiniObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = ast.syncSchemaRef(schema);
+		const meta = syncSchemaRef(schema);
 		const value = applyMiniModifiers({
 			value: baseOutput,
 			schema,
@@ -1193,8 +1361,10 @@ const printerZodMini = ast.createPrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
+				const pattern = node.pattern ?? integerFormatPattern(node.format);
 				return `z.string()${lengthChecksMini({
 					...node,
+					pattern,
 					regexType: this.options.regexType
 				})}`;
 			},
@@ -1282,18 +1452,18 @@ const printerZodMini = ast.createPrinter((options) => {
 				return objectBase;
 			},
 			array(node) {
-				const base = `z.array(${ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
 					...node,
 					regexType: this.options.regexType
 				})}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = ast.mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
@@ -1324,7 +1494,7 @@ const printerZodMini = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyMiniModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1521,7 +1691,6 @@ const zodGenerator = defineGenerator({
 		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = getOasAdapter(adapter).options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.file({
 			name: node.operationId,
 			extname: ".ts",
@@ -1627,7 +1796,7 @@ const zodGenerator = defineGenerator({
 				name
 			});
 		}
-		const paramSchemas = params.map((param) => renderSchemaEntry({
+		const paramSchemas = node.parameters.map((param) => renderSchemaEntry({
 			schema: param.schema,
 			name: resolver.param.name(node, param),
 			direction: "input"
@@ -1676,6 +1845,30 @@ const zodGenerator = defineGenerator({
 				description: node.requestBody.description ?? schema.description
 			}), "input");
 		})();
+		const { path, query, header } = getOperationParameters(node);
+		const paramGroupSchemas = inferred ? [
+			{
+				kind: "path",
+				params: path
+			},
+			{
+				kind: "query",
+				params: query
+			},
+			{
+				kind: "headers",
+				params: header
+			}
+		].filter(({ params }) => params.length > 0).map(({ kind, params }) => renderSchemaEntry({
+			schema: buildGroupedParamsSchema({ params }),
+			name: resolver.param[kind](node, params[0]),
+			direction: "input"
+		})) : [];
+		const optionsSchema = inferred ? renderSchemaEntry({
+			schema: buildOptionsSchema(node, resolver),
+			name: resolver.name(`${node.operationId} Options`),
+			direction: "input"
+		}) : null;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -1706,7 +1899,9 @@ const zodGenerator = defineGenerator({
 				responseSchemas,
 				responseUnionSchema,
 				errorUnionSchema,
-				requestSchema
+				requestSchema,
+				paramGroupSchemas,
+				optionsSchema
 			]
 		});
 	}
@@ -1748,22 +1943,14 @@ const resolverZod = createResolver({
 			return this.schema.typeName(`${name} input`);
 		}
 	},
-	param: {
-		name: operationParamName,
-		path(node, param) {
-			return this.param.name(node, param);
-		},
-		query(node, param) {
-			return this.param.name(node, param);
-		},
-		headers(node, param) {
-			return this.param.name(node, param);
-		}
-	},
+	param: createOperationParamResolver(),
 	response: {
 		...createOperationResponseResolver(),
 		error(node) {
 			return this.name(`${node.operationId} Error`);
+		},
+		options(node) {
+			return this.schema.type(this.name(`${node.operationId} Options`));
 		}
 	}
 });