@kubb/plugin-zod 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/index.js

@@ -1,6 +1,6 @@
-import "./chunk--u3MIqq1.js";
+import { t as __name } from "./chunk--u3MIqq1.js";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { Const, File, Type, jsxRenderer } from "@kubb/renderer-jsx";
+import { Const, File, Type, jsxRendererSync } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -126,6 +126,212 @@ function toRegExpString(text, func = "RegExp") {
 	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
+*
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+//#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
+		};
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+*
+* Returns `null` when grouping is disabled, matching the per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
+* @param options.honorName - When `true`, a user-provided `group.name` overrides the default namer.
+*
+* @example
+* ```ts
+* createGroupConfig(group, { suffix: 'Controller' })                  // plugin-ts, plugin-zod
+* createGroupConfig(group, { suffix: 'Controller', honorName: true }) // plugin-faker, plugin-client, …
+* createGroupConfig(group, { suffix: 'Requests', honorName: true })   // plugin-cypress, plugin-mcp
+* ```
+*/
+function createGroupConfig(group, options) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return `${camelCase(ctx.group)}${options.suffix}`;
+	};
+	return {
+		...group,
+		name: options.honorName && group.name ? group.name : defaultName
+	};
+}
+//#endregion
 //#region src/components/Operations.tsx
 function Operations({ name, operations }) {
 	const operationsJSON = operations.reduce((prev, acc) => {
@@ -133,6 +339,7 @@ function Operations({ name, operations }) {
 		return prev;
 	}, {});
 	const pathsJSON = operations.reduce((prev, acc) => {
+		if (!ast.isHttpOperationNode(acc.node)) return prev;
 		prev[`"${acc.node.path}"`] = {
 			...prev[`"${acc.node.path}"`] ?? {},
 			[acc.node.method]: `operations["${acc.node.operationId}"]`
@@ -242,6 +449,61 @@ function shouldCoerce(coercion, type) {
 	return !!coercion[type];
 }
 /**
+* Registered codecs, checked in order.
+*/
+const codecs = [{
+	matches(node) {
+		return node.type === "date" && node.representation === "date";
+	},
+	decode(node) {
+		return node.format === "date" ? "z.iso.date().transform((value) => new Date(value))" : "z.iso.datetime().transform((value) => new Date(value))";
+	},
+	encode(node) {
+		return node.format === "date" ? "z.date().transform((value) => value.toISOString().slice(0, 10))" : "z.date().transform((value) => value.toISOString())";
+	}
+}];
+/**
+* Returns the codec for this node, or `undefined` when the node needs no
+* encode/decode (its wire and runtime types match).
+*/
+function getCodec(node) {
+	if (!node) return void 0;
+	return codecs.find((codec) => codec.matches(node));
+}
+/**
+* Returns `true` when the node itself is encoded/decoded by a codec.
+*/
+function hasCodec(node) {
+	return getCodec(node) !== void 0;
+}
+/**
+* Returns `true` when the schema transitively contains a codec node —
+* a value whose runtime type differs from its wire type (see {@link hasCodec}),
+* so it must be decoded (response) or encoded (request) at the validation boundary.
+* `$ref`s are followed via their resolved schema; a `seen` set guards cycles.
+*/
+function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
+	if (!node) return false;
+	if (hasCodec(node)) return true;
+	if (node.type === "ref") {
+		if (!node.ref) return false;
+		const refName = ast.extractRefName(node.ref);
+		if (refName) {
+			if (seen.has(refName)) return false;
+			seen.add(refName);
+		}
+		const resolved = ast.syncSchemaRef(node);
+		if (resolved.type === "ref") return false;
+		return containsCodec(resolved, seen);
+	}
+	const children = [];
+	if ("properties" in node && node.properties) children.push(...node.properties.map((prop) => prop.schema));
+	if ("items" in node && node.items) children.push(...node.items);
+	if ("members" in node && node.members) children.push(...node.members);
+	if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
+	return children.some((child) => containsCodec(child, seen));
+}
+/**
 * Collects all resolved schema names for an operation's parameters and responses
 * into a single lookup object, useful for building imports and type references.
 */
@@ -261,11 +523,11 @@ function buildSchemaNames(node, { params, resolver }) {
 	}
 	responses["default"] = resolver.resolveResponseName(node);
 	return {
-		request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0,
+		request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null,
 		parameters: {
-			path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : void 0,
-			query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : void 0,
-			header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : void 0
+			path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : null,
+			query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : null,
+			header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : null
 		},
 		responses,
 		errors
@@ -339,30 +601,44 @@ function lengthChecksMini({ min, max, pattern }) {
 * to a schema value string using the chainable Zod v4 API.
 */
 function applyModifiers({ value, nullable, optional, nullish, defaultValue, description }) {
-	let result = value;
-	if (nullish || nullable && optional) result = `${result}.nullish()`;
-	else if (optional) result = `${result}.optional()`;
-	else if (nullable) result = `${result}.nullable()`;
-	if (defaultValue !== void 0) result = `${result}.default(${formatDefault(defaultValue)})`;
-	if (description) result = `${result}.describe(${stringify(description)})`;
-	return result;
+	const withModifier = (() => {
+		if (nullish || nullable && optional) return `${value}.nullish()`;
+		if (optional) return `${value}.optional()`;
+		if (nullable) return `${value}.nullable()`;
+		return value;
+	})();
+	const withDefault = defaultValue !== void 0 ? `${withModifier}.default(${formatDefault(defaultValue)})` : withModifier;
+	return description ? `${withDefault}.describe(${stringify(description)})` : withDefault;
 }
 /**
 * Apply nullable / optional / nullish modifiers using the functional `zod/mini` API
 * (`z.nullable()`, `z.optional()`, `z.nullish()`).
 */
 function applyMiniModifiers({ value, nullable, optional, nullish, defaultValue }) {
-	let result = value;
-	if (nullish) result = `z.nullish(${result})`;
-	else {
-		if (nullable) result = `z.nullable(${result})`;
-		if (optional) result = `z.optional(${result})`;
-	}
-	if (defaultValue !== void 0) result = `z._default(${result}, ${formatDefault(defaultValue)})`;
-	return result;
+	const withModifier = (() => {
+		if (nullish) return `z.nullish(${value})`;
+		const withNullable = nullable ? `z.nullable(${value})` : value;
+		return optional ? `z.optional(${withNullable})` : withNullable;
+	})();
+	return defaultValue !== void 0 ? `z._default(${withModifier}, ${formatDefault(defaultValue)})` : withModifier;
 }
 //#endregion
 //#region src/printers/printerZod.ts
+function strictOneOfMember$1(member, node) {
+	if (node.type === "object" && node.additionalProperties === void 0) return `${member}.strict()`;
+	if (node.type === "ref") {
+		if (member.startsWith("z.lazy(")) return member;
+		const schema = ast.syncSchemaRef(node);
+		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+	}
+	return member;
+}
+__name(strictOneOfMember$1, "strictOneOfMember");
+function getMemberConstraint(member) {
+	if (member.primitive === "string") return lengthConstraints(ast.narrowSchema(member, "string") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthConstraints(ast.narrowSchema(member, "array") ?? {}) || void 0;
+}
 /**
 * Zod v4 printer built with `definePrinter`.
 *
@@ -399,8 +675,9 @@ const printerZod = ast.definePrinter((options) => {
 				return shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.bigint()" : "z.bigint()";
 			},
 			date(node) {
-				if (node.representation === "string") return "z.iso.date()";
-				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+				const codec = getCodec(node);
+				if (codec) return this.options.direction === "input" ? codec.encode(node) : codec.decode(node);
+				return "z.iso.date()";
 			},
 			datetime(node) {
 				const offset = node.offset || this.options.dateType === "stringOffset";
@@ -435,29 +712,30 @@ const printerZod = ast.definePrinter((options) => {
 				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
 			},
 			ref(node) {
-				if (!node.name) return void 0;
+				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
-				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
+				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.resolveInputSchemaName(refName) ?? refName : this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				let result = `z.object({\n    ${node.properties.map((prop) => {
+				const objectBase = `z.object({\n    ${node.properties.map((prop) => {
 					const { name: propName, schema } = prop;
 					const meta = ast.syncSchemaRef(schema);
 					const isNullable = meta.nullable;
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
 					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
 					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
 					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
 						output: baseOutput,
 						schema
 					}) || baseOutput : baseOutput;
-					let descriptionToApply = meta.description;
-					if (schema.type !== "ref" && meta.type === "ref") descriptionToApply = void 0;
+					const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 					const value = applyModifiers({
 						value: wrappedOutput,
 						nullable: isNullable,
@@ -469,24 +747,29 @@ const printerZod = ast.definePrinter((options) => {
 					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
 					return `"${propName}": ${value}`;
 				}).join(",\n    ")}\n    })`;
-				if (node.additionalProperties && node.additionalProperties !== true) {
-					const catchallType = this.transform(node.additionalProperties);
-					if (catchallType) result += `.catchall(${catchallType})`;
-				} else if (node.additionalProperties === true) result += `.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
-				else if (node.additionalProperties === false) result += ".strict()";
-				return result;
+				return (() => {
+					if (node.additionalProperties && node.additionalProperties !== true) {
+						const catchallType = this.transform(node.additionalProperties);
+						return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase;
+					}
+					if (node.additionalProperties === true) return `${objectBase}.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
+					if (node.additionalProperties === false) return `${objectBase}.strict()`;
+					return objectBase;
+				})();
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
-				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
-				return result;
+				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
+				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
 				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((m) => this.transform(m)).filter(Boolean);
+				const members = nodeMembers.map((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember$1(member, memberNode) : member;
+				}).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
@@ -497,47 +780,29 @@ const printerZod = ast.definePrinter((options) => {
 				if (members.length === 0) return "";
 				const [first, ...rest] = members;
 				if (!first) return "";
-				let base = this.transform(first);
-				if (!base) return "";
-				for (const member of rest) {
-					if (member.primitive === "string") {
-						const c = lengthConstraints(ast.narrowSchema(member, "string") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "array") {
-						const c = lengthConstraints(ast.narrowSchema(member, "array") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					}
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraint(member);
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `${base}.and(${transformed})`;
-				}
-				return base;
+					return transformed ? `${acc}.and(${transformed})` : acc;
+				}, firstBase);
 			},
 			...options.nodes
 		},
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = ast.syncSchemaRef(node);
-			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
-				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
-				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
-				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
-			}
 			return applyModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+					return `${transformed}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+				})(),
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
@@ -549,6 +814,15 @@ const printerZod = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/printers/printerZodMini.ts
+function strictOneOfMember(member, node) {
+	if (node.type === "object" && (node.additionalProperties === void 0 || node.additionalProperties === false)) return member.replace(/^z\.object\(/, "z.strictObject(");
+	return member;
+}
+function getMemberConstraintMini(member) {
+	if (member.primitive === "string") return lengthChecksMini(ast.narrowSchema(member, "string") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthChecksMini(ast.narrowSchema(member, "array") ?? {}) || void 0;
+}
 /**
 * Zod v4 **Mini** printer built with `definePrinter`.
 *
@@ -617,7 +891,7 @@ const printerZodMini = ast.definePrinter((options) => {
 				return `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
 			},
 			ref(node) {
-				if (!node.name) return void 0;
+				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
@@ -631,9 +905,10 @@ const printerZodMini = ast.definePrinter((options) => {
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
 					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
 					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
 					const value = applyMiniModifiers({
 						value: this.options.wrapOutput ? this.options.wrapOutput({
 							output: baseOutput,
@@ -649,16 +924,18 @@ const printerZodMini = ast.definePrinter((options) => {
 				}).join(",\n    ")}\n    })`;
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
-				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
-				return result;
+				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
+				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
 				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = nodeMembers.map((m) => this.transform(m)).filter(Boolean);
+				const members = nodeMembers.map((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember(member, memberNode) : member;
+				}).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
@@ -669,47 +946,29 @@ const printerZodMini = ast.definePrinter((options) => {
 				if (members.length === 0) return "";
 				const [first, ...rest] = members;
 				if (!first) return "";
-				let base = this.transform(first);
-				if (!base) return "";
-				for (const member of rest) {
-					if (member.primitive === "string") {
-						const c = lengthChecksMini(ast.narrowSchema(member, "string") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					} else if (member.primitive === "array") {
-						const c = lengthChecksMini(ast.narrowSchema(member, "array") ?? {});
-						if (c) {
-							base += c;
-							continue;
-						}
-					}
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraintMini(member);
+					if (constraint) return acc + constraint;
 					const transformed = this.transform(member);
-					if (transformed) base = `z.intersection(${base}, ${transformed})`;
-				}
-				return base;
+					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
+				}, firstBase);
 			},
 			...options.nodes
 		},
 		print(node) {
 			const { keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = ast.syncSchemaRef(node);
-			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
-				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
-				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
-				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
-			}
 			return applyMiniModifiers({
-				value: base,
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+					return `${transformed}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+				})(),
 				nullable: meta.nullable,
 				optional: meta.optional,
 				nullish: meta.nullish,
@@ -720,9 +979,65 @@ const printerZodMini = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/generators/zodGenerator.tsx
+const zodPrinterCache = /* @__PURE__ */ new WeakMap();
+const zodMiniPrinterCache = /* @__PURE__ */ new WeakMap();
+/**
+* Returns the cached `output`/`input` direction printers for a resolver, building them on
+* first use. The `input` printer encodes `Date → string` for request bodies; `output` decodes
+* `string → Date` for responses. Schemas without `dateType: 'date'` fields print identically.
+*/
+function getStdPrinters(resolver, params) {
+	const cached = zodPrinterCache.get(resolver);
+	if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.dateType === params.dateType) return {
+		output: cached.output,
+		input: cached.input
+	};
+	const base = {
+		...params,
+		resolver
+	};
+	const output = printerZod({
+		...base,
+		direction: "output"
+	});
+	const input = printerZod({
+		...base,
+		direction: "input"
+	});
+	zodPrinterCache.set(resolver, {
+		output,
+		input,
+		coercion: params.coercion,
+		guidType: params.guidType,
+		dateType: params.dateType
+	});
+	return {
+		output,
+		input
+	};
+}
+function getMiniPrinter(resolver, params) {
+	const cached = zodMiniPrinterCache.get(resolver);
+	if (cached && cached.guidType === params.guidType) return cached.printer;
+	const p = printerZodMini({
+		...params,
+		resolver
+	});
+	zodMiniPrinterCache.set(resolver, {
+		printer: p,
+		guidType: params.guidType
+	});
+	return p;
+}
+/**
+* Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
+* schema in the spec plus per-operation request/response/parameter schemas.
+* When `mini: true`, schemas use the Zod Mini functional API instead of
+* chainable methods.
+*/
 const zodGenerator = defineGenerator({
 	name: "zod",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
@@ -730,7 +1045,10 @@ const zodGenerator = defineGenerator({
 		if (!node.name) return;
 		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const imports = adapter.getImports(node, (schemaName) => ({
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const hasCodec = !mini && containsCodec(node);
+		const codecRefNames = new Set(hasCodec ? ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 }) : []);
+		const importEntries = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveSchemaName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
@@ -738,9 +1056,27 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
 		}));
+		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
+			name: resolver.resolveInputSchemaName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			}).path
+		})) : [];
+		const seenImports = /* @__PURE__ */ new Set();
+		const imports = [...importEntries, ...inputImportEntries].filter((imp) => {
+			const key = `${Array.isArray(imp.name) ? imp.name.join(",") : imp.name}|${imp.path}`;
+			if (seenImports.has(key)) return false;
+			seenImports.add(key);
+			return true;
+		});
 		const meta = {
 			name: resolver.resolveSchemaName(node.name),
 			file: resolver.resolveFile({
@@ -749,37 +1085,43 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			})
 		};
-		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : void 0;
-		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
-		const schemaPrinter = mini ? printerZodMini({
+		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null;
+		const stdPrinters = mini ? null : getStdPrinters(resolver, {
+			coercion,
 			guidType,
+			dateType,
 			wrapOutput,
-			resolver,
 			cyclicSchemas,
 			nodes: printer?.nodes
-		}) : printerZod({
-			coercion,
+		});
+		const schemaPrinter = mini ? getMiniPrinter(resolver, {
 			guidType,
-			dateType,
 			wrapOutput,
-			resolver,
 			cyclicSchemas,
 			nodes: printer?.nodes
-		});
+		}) : stdPrinters.output;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -791,17 +1133,28 @@ const zodGenerator = defineGenerator({
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
-				}, [node.name, imp.path].join("-"))),
+				}, [
+					node.name,
+					imp.path,
+					imp.name
+				].join("-"))),
 				/* @__PURE__ */ jsx(Zod, {
 					name: meta.name,
 					node,
 					printer: schemaPrinter,
 					inferTypeName
+				}),
+				hasCodec && stdPrinters && /* @__PURE__ */ jsx(Zod, {
+					name: resolver.resolveInputSchemaName(node.name),
+					node,
+					printer: stdPrinters.input,
+					inferTypeName: inferred ? resolver.resolveInputSchemaTypeName(node.name) : null
 				})
 			]
 		});
 	},
 	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
@@ -816,31 +1169,37 @@ const zodGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
-		function renderSchemaEntry({ schema, name, keysToOmit }) {
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
 			if (!schema) return null;
-			const inferTypeName = inferred ? resolver.resolveTypeName(name) : void 0;
+			const inferTypeName = inferred ? resolver.resolveTypeName(name) : null;
+			const codecRefNames = direction === "input" && !mini ? new Set(ast.collect(schema, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 })) : null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
+				name: codecRefNames?.has(schemaName) ? resolver.resolveInputSchemaName(schemaName) : resolver.resolveSchemaName(schemaName),
 				path: resolver.resolveFile({
 					name: schemaName,
 					extname: ".ts"
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				}).path
 			}));
-			const schemaPrinter = mini ? printerZodMini({
+			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
 				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
 				nodes: printer?.nodes
-			}) : printerZod({
+			}) : getMiniPrinter(resolver, {
+				guidType,
+				wrapOutput,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : keysToOmit?.length ? printerZod({
 				coercion,
 				guidType,
 				dateType,
@@ -848,8 +1207,16 @@ const zodGenerator = defineGenerator({
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
+				nodes: printer?.nodes,
+				direction
+			}) : getStdPrinters(resolver, {
+				coercion,
+				guidType,
+				dateType,
+				wrapOutput,
+				cyclicSchemas,
 				nodes: printer?.nodes
-			});
+			})[direction];
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
@@ -865,22 +1232,48 @@ const zodGenerator = defineGenerator({
 				inferTypeName
 			})] });
 		}
+		function buildContentTypeVariants(entries, baseName, decorate, direction) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaEntry({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit,
+				direction
+			})), renderSchemaEntry({
+				schema: unionSchema,
+				name: baseName,
+				direction
+			})] });
+		}
 		const paramSchemas = params.map((param) => renderSchemaEntry({
 			schema: param.schema,
-			name: resolver.resolveParamName(node, param)
-		}));
-		const responseSchemas = node.responses.map((res) => renderSchemaEntry({
-			schema: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
+			name: resolver.resolveParamName(node, param),
+			direction: "input"
 		}));
-		const responsesWithSchema = node.responses.filter((res) => res.schema);
+		const responseSchemas = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.resolveResponseStatusName(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaEntry({
+				schema: primary?.schema ?? null,
+				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
+			});
+		});
+		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
 			const responseUnionName = resolver.resolveResponseName(node);
-			if (new Set(responsesWithSchema.flatMap((res) => res.schema ? adapter.getImports(res.schema, (schemaName) => ({
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
 				name: resolver.resolveSchemaName(schemaName),
 				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseUnionName)) return null;
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseUnionName)) return null;
 			const members = responsesWithSchema.map((res) => ast.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
@@ -893,25 +1286,46 @@ const zodGenerator = defineGenerator({
 				name: responseUnionName
 			});
 		})() : null;
-		const requestSchema = node.requestBody?.content?.[0]?.schema ? renderSchemaEntry({
-			schema: {
-				...node.requestBody.content[0].schema,
-				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
-			},
-			name: resolver.resolveDataName(node),
-			keysToOmit: node.requestBody.content[0].keysToOmit
-		}) : null;
+		const requestBodyContent = node.requestBody?.content ?? [];
+		const requestSchema = (() => {
+			if (requestBodyContent.length === 0) return null;
+			if (requestBodyContent.length === 1) {
+				const entry = requestBodyContent[0];
+				if (!entry.schema) return null;
+				return renderSchemaEntry({
+					schema: {
+						...entry.schema,
+						description: node.requestBody.description ?? entry.schema.description
+					},
+					name: resolver.resolveDataName(node),
+					keysToOmit: entry.keysToOmit,
+					direction: "input"
+				});
+			}
+			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}), "input");
+		})();
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -927,7 +1341,7 @@ const zodGenerator = defineGenerator({
 		});
 	},
 	operations(nodes, ctx) {
-		const { adapter, config, resolver, root } = ctx;
+		const { config, resolver, root } = ctx;
 		const { output, importPath, group, operations, paramsCasing } = ctx.options;
 		if (!operations) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
@@ -937,9 +1351,9 @@ const zodGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const transformedOperations = nodes.map((node) => {
+		const transformedOperations = nodes.filter(ast.isHttpOperationNode).map((node) => {
 			return {
 				node,
 				data: buildSchemaNames(node, {
@@ -962,7 +1376,7 @@ const zodGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
 			return names.map((name) => /* @__PURE__ */ jsx(File.Import, {
 				name: [name],
@@ -974,13 +1388,21 @@ const zodGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
@@ -1001,77 +1423,102 @@ const zodGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverZod.ts
 /**
-* Naming convention resolver for Zod plugin.
+* Default resolver used by `@kubb/plugin-zod`. Decides the names and file
+* paths for every generated Zod schema. Schemas use camelCase with a
+* `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase.
 *
-* Provides default naming helpers using camelCase with a `Schema` suffix for schemas.
+* @example Resolve schema and type names
+* ```ts
+* import { resolverZod } from '@kubb/plugin-zod'
 *
-* @example
-* `resolverZod.default('list pets', 'function')  // → 'listPetsSchema'`
+* resolverZod.default('list pets', 'function') // 'listPetsSchema'
+* resolverZod.resolveSchemaTypeName('pet')     // 'PetSchema'
+* ```
 */
-const resolverZod = defineResolver((ctx) => {
+const resolverZod = defineResolver(() => {
 	return {
 		name: "default",
 		pluginName: "plugin-zod",
 		default(name, type) {
-			return camelCase(name, {
+			const resolved = camelCase(name, {
 				isFile: type === "file",
 				suffix: type ? "schema" : void 0
 			});
+			return type === "file" ? resolved : ensureValidVarName(resolved);
 		},
 		resolveSchemaName(name) {
-			return camelCase(name, { suffix: "schema" });
+			return ensureValidVarName(camelCase(name, { suffix: "schema" }));
 		},
 		resolveSchemaTypeName(name) {
-			return pascalCase(name, { suffix: "schema" });
+			return ensureValidVarName(pascalCase(name, { suffix: "schema" }));
+		},
+		resolveInputSchemaName(name) {
+			return this.resolveSchemaName(`${name} input`);
+		},
+		resolveInputSchemaTypeName(name) {
+			return this.resolveSchemaTypeName(`${name} input`);
 		},
 		resolveTypeName(name) {
-			return pascalCase(name);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolvePathName(name, type) {
-			return ctx.default(name, type);
+			return this.default(name, type);
 		},
 		resolveParamName(node, param) {
-			return ctx.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
+			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
 		},
 		resolveResponseStatusName(node, statusCode) {
-			return ctx.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
+			return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
 		},
 		resolveDataName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Data`);
+			return this.resolveSchemaName(`${node.operationId} Data`);
 		},
 		resolveResponsesName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Responses`);
+			return this.resolveSchemaName(`${node.operationId} Responses`);
 		},
 		resolveResponseName(node) {
-			return ctx.resolveSchemaName(`${node.operationId} Response`);
+			return this.resolveSchemaName(`${node.operationId} Response`);
 		},
 		resolvePathParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveQueryParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveHeaderParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		}
 	};
 });
 //#endregion
 //#region src/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+* Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
+* cross-plugin dependency references.
 */
 const pluginZodName = "plugin-zod";
 /**
-* Generates Zod validation schemas from an OpenAPI specification.
-* Walks schemas and operations, delegates to generators, and writes barrel files
-* based on the configured `barrelType`.
+* Generates Zod v4 schemas from an OpenAPI spec. Use them to validate API
+* responses at runtime, build form schemas, or feed back into router libraries
+* that consume Zod (tRPC, Hono, Elysia). Pair with `@kubb/plugin-client` and
+* set the client's `parser: 'zod'` to validate every response automatically.
 *
-* @example Zod schema generator
+* @example
 * ```ts
-* import pluginZod from '@kubb/plugin-zod'
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginZod } from '@kubb/plugin-zod'
+*
 * export default defineConfig({
-*   plugins: [pluginZod({ output: { path: 'zod' } })]
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginZod({
+*       output: { path: './zod' },
+*       typed: true,
+*     }),
+*   ],
 * })
 * ```
 */
@@ -1080,13 +1527,7 @@ const pluginZod = definePlugin((options) => {
 		path: "zod",
 		barrelType: "named"
 	}, group, exclude = [], include, override = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
 	return {
 		name: pluginZodName,
 		options,