@kubb/plugin-zod 5.0.0-alpha.9 → 5.0.0-beta.100

package/dist/index.cjs

@@ -1,12 +1,179 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_components = require("./components-B7zUFnAm.cjs");
-const require_generators = require("./generators-BjPDdJUz.cjs");
-const require_templates_ToZod_source = require("./templates/ToZod.source.cjs");
-let node_path = require("node:path");
-node_path = require_components.__toESM(node_path);
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_oas = require("@kubb/plugin-oas");
-let _kubb_plugin_ts = require("@kubb/plugin-ts");
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+let kubb_kit = require("kubb/kit");
+let kubb_jsx = require("kubb/jsx");
+let kubb_jsx_jsx_runtime = require("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
+		};
+	});
+}
+function getOperationParameters(node) {
+	return {
+		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"))
+	};
+}
+/**
+* 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 = () => kubb_kit.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 kubb_kit.ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [kubb_kit.ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? kubb_kit.ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return kubb_kit.ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? kubb_kit.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.
@@ -18,161 +185,1825 @@ let _kubb_plugin_ts = require("@kubb/plugin-ts");
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ 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
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
 }
 /**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* 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
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region src/plugin.ts
-const pluginZodName = "plugin-zod";
-const pluginZod = (0, _kubb_core.createPlugin)((options) => {
-	const { output = {
-		path: "zod",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, dateType = "string", unknownType = "any", emptySchemaType = unknownType, integerType = "number", typed = false, mapper = {}, operations = false, mini = false, version = mini ? "4" : (0, _kubb_core.satisfiesDependency)("zod", ">=4") ? "4" : "3", guidType = "uuid", importPath = mini ? "zod/mini" : version === "4" ? "zod/v4" : "zod", coercion = false, inferred = false, generators = [require_generators.zodGenerator, operations ? require_generators.operationsGenerator : void 0].filter(Boolean), wrapOutput = void 0, contentType } = options;
+//#region ../../internals/utils/src/strings.ts
+/**
+* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
+* any backslash or single quote in the content.
+*
+* @example
+* ```ts
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
+* ```
+*/
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* ```ts
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
+* ```
+*/
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
+}
+/**
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+*
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
+*
+* @example
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+//#endregion
+//#region ../../internals/utils/src/codegen.ts
+const INDENT = "  ";
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
+*
+* @example
+* ```ts
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
+}
+/**
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
+*
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+/**
+* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
+* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
+*
+* @example
+* ```ts
+* buildList(['z.string()', 'z.number()'])
+* // '[z.string(), z.number()]'
+* ```
+*/
+function buildList(items, brackets = ["[", "]"]) {
+	const [open, close] = brackets;
+	if (items.length === 0) return `${open}${close}`;
+	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
+	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+}
+/**
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
+*
+* @example
+* ```ts
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
+* ```
+*/
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region ../../internals/shared/src/resolver.ts
+/**
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
+*
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+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: pluginZodName,
-		options: {
-			output,
-			transformers,
-			include,
-			exclude,
-			override,
-			typed,
-			dateType,
-			unknownType,
-			emptySchemaType,
-			integerType,
-			mapper,
-			importPath,
-			coercion,
-			operations,
-			inferred,
-			group,
-			wrapOutput,
-			version,
-			guidType,
-			mini,
-			usedEnumNames: {}
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
 		},
-		pre: [_kubb_plugin_oas.pluginOasName, typed ? _kubb_plugin_ts.pluginTsName : void 0].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? (0, _kubb_core.getMode)(node_path.default.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return node_path.default.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Controller`;
-				};
-				return node_path.default.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+		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.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
+* ```
+*/
+function createOperationResponseResolver() {
+	return {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
+	};
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/refs.ts
+/**
+* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
+* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
+* `resolver.imports` would resolve file paths that are then discarded.
+*/
+function collectRefNames(schema) {
+	return kubb_kit.ast.collectSync(schema, { schema: (node) => {
+		const refNode = kubb_kit.ast.narrowSchema(node, "ref");
+		if (!refNode?.ref) return null;
+		return kubb_kit.ast.resolveRefName(refNode);
+	} });
+}
+//#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 the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#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);
+	if (!output) return;
+	const needsAnnotation = cyclic && node.type !== "object";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Const, {
+			export: true,
+			name,
+			type: needsAnnotation ? "z.ZodType" : void 0,
+			children: output
+		})
+	}), inferTypeName && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name: inferTypeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Type, {
+			export: true,
+			name: inferTypeName,
+			children: `z.infer<typeof ${name}>`
+		})
+	})] });
+}
+//#endregion
+//#region src/constants.ts
+/**
+* Import paths that use a namespace import (`import * as z from '...'`).
+* All other import paths use a named import (`import { z } from '...'`).
+*/
+const ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["zod", "zod/mini"]);
+//#endregion
+//#region src/utils.ts
+/**
+* Returns `true` when the given coercion option enables coercion for the specified type.
+*/
+function shouldCoerce(coercion, type) {
+	if (coercion === void 0 || coercion === false) return false;
+	if (coercion === true) return true;
+	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 = (0, kubb_kit.extractRefName)(node.ref);
+		if (refName) {
+			if (seen.has(refName)) return false;
+			seen.add(refName);
+		}
+		const resolved = (0, kubb_kit.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 the names of `$ref` schemas that transitively contain a codec, so the generator can route
+* them to their input (encode) variant.
+*/
+function collectCodecRefNames(node) {
+	return kubb_kit.ast.collectSync(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? kubb_kit.ast.resolveRefName(n) ?? void 0 : void 0 });
+}
+/**
+* Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
+* argument. A catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
+* on `.and(…)`.
+*/
+function isPlainInlineObject(node) {
+	return node.type === "object" && !node.nullable && !node.optional && !node.nullish && node.additionalProperties === void 0 && !node.patternProperties;
+}
+/**
+* Whether a node renders as a bare Zod object — one that accepts `.extend(…)` and can be a
+* `z.discriminatedUnion` option. Covers object nodes, `$ref`s that resolve to (or are still
+* unresolved) objects, single-member unions of an object, and object-composable `allOf`.
+*
+* `cyclicSchemas` bounds the recursion: a ref into a cycle renders as `z.lazy(…)`, not an object.
+*/
+function isObjectSchemaNode(node, cyclicSchemas) {
+	if (node.nullable || node.optional || node.nullish) return false;
+	if (node.type === "object") return true;
+	if (node.type === "ref") {
+		const refName = kubb_kit.ast.resolveRefName(node);
+		if (refName && cyclicSchemas?.has(refName)) return false;
+		const resolved = (0, kubb_kit.syncSchemaRef)(node);
+		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
+	}
+	if (node.type === "union") {
+		const members = node.members ?? [];
+		return members.length === 1 && isObjectSchemaNode(members[0], cyclicSchemas);
+	}
+	return isObjectComposableIntersection(node, cyclicSchemas);
+}
+/**
+* Whether an `allOf` is a pure object composition — an object base plus inline object members whose
+* shapes merge with `.extend(…)`. These stay a Zod object instead of a `ZodIntersection`, which
+* `z.discriminatedUnion` rejects.
+*/
+function isObjectComposableIntersection(node, cyclicSchemas) {
+	if (node.type !== "intersection") return false;
+	const [first, ...rest] = node.members ?? [];
+	return !!first && isObjectSchemaNode(first, cyclicSchemas) && rest.every(isPlainInlineObject);
+}
+/**
+* Format a default value as a code-level literal.
+* Objects become `{}`, primitives become their string representation, strings are quoted.
+*/
+function formatDefault(value) {
+	if (typeof value === "string") return stringify(value);
+	if (typeof value === "object" && value !== null) return "{}";
+	return String(value ?? "");
+}
+/**
+* Format a default for `.default(...)` so the literal matches the generated schema's type.
+*
+* An OpenAPI `default` does not always agree with the schema it sits on: a `bigint` field
+* (`format: int64`) carries a `number` default, and a spec may put `default: {}` on an `array`.
+* Emitting those verbatim produces a Zod schema that does not typecheck, so coerce the bigint case
+* to a `BigInt(...)` literal and emit an array literal for arrays (dropping a non-array default).
+* Returns `null` when no `.default(...)` should be emitted. Keys off the schema node's type.
+*/
+function defaultLiteral(node, value) {
+	if (value === null) return null;
+	if (node && kubb_kit.ast.narrowSchema(node, "bigint")) {
+		if (typeof value === "bigint") return `BigInt(${value})`;
+		if (typeof value === "number" && Number.isInteger(value)) return `BigInt(${value})`;
+		return null;
+	}
+	if (node && kubb_kit.ast.narrowSchema(node, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
+	const enumNode = node ? kubb_kit.ast.narrowSchema(node, "enum") : void 0;
+	if (enumNode) {
+		const values = enumNode.namedEnumValues?.map((member) => member.value) ?? enumNode.enumValues ?? [];
+		if (values.length) {
+			const match = values.find((member) => member === value || String(member) === String(value));
+			return match != null ? formatLiteral(match) : null;
+		}
+	}
+	return formatDefault(value);
+}
+/**
+* Format a primitive enum/literal value.
+* Strings are quoted; numbers and booleans are emitted raw.
+*/
+function formatLiteral(v) {
+	if (typeof v === "string") return stringify(v);
+	return String(v);
+}
+/**
+* Build the Zod schema for a set of literal enum values.
+* `z.enum()` only accepts string members in Zod v4, so a numeric, boolean, or
+* mixed set is emitted as a single `z.literal(…)` or a `z.union([z.literal(…), …])`.
+* An all-string set keeps the more compact `z.enum([…])`.
+*/
+function buildEnum(values) {
+	if (values.every((v) => typeof v === "string")) return `z.enum([${values.map(formatLiteral).join(", ")}])`;
+	const literals = values.map((v) => `z.literal(${formatLiteral(v)})`);
+	if (literals.length === 1) return literals[0];
+	return `z.union([${literals.join(", ")}])`;
+}
+/**
+* Map a `regexType` to the `func` argument of `toRegExpString`: `'constructor'` emits
+* `new RegExp(...)`, while `'literal'` (the default) emits a regex literal.
+*/
+function regexFunc(regexType) {
+	return regexType === "constructor" ? "RegExp" : null;
+}
+/**
+* Builds a Zod record key schema that enforces the `patternProperties` regexes a plain
+* `.catchall()` would drop. Several patterns combine into one alternation (`(^a)|(^b)`).
+*/
+function patternKeySchema({ patterns, regexType }) {
+	return `z.string().regex(${patternKeySource({
+		patterns,
+		regexType
+	})})`;
+}
+/**
+* `zod/mini` variant of {@link patternKeySchema}, wrapping the regex in `.check(z.regex(...))`.
+*/
+function patternKeySchemaMini({ patterns, regexType }) {
+	return `z.string().check(z.regex(${patternKeySource({
+		patterns,
+		regexType
+	})}))`;
+}
+function patternKeySource({ patterns, regexType }) {
+	return toRegExpString(patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|"), regexFunc(regexType));
+}
+/**
+* Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
+* using the standard chainable Zod v4 API.
+*/
+function numberConstraints({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }) {
+	return [
+		min !== void 0 ? `.min(${min})` : "",
+		max !== void 0 ? `.max(${max})` : "",
+		exclusiveMinimum !== void 0 ? `.gt(${exclusiveMinimum})` : "",
+		exclusiveMaximum !== void 0 ? `.lt(${exclusiveMaximum})` : "",
+		multipleOf !== void 0 ? `.multipleOf(${multipleOf})` : ""
+	].join("");
+}
+/**
+* Build `.min()` / `.max()` / `.regex()` chains for strings/arrays
+* using the standard chainable Zod v4 API.
+*/
+function lengthConstraints({ min, max, pattern, regexType }) {
+	return [
+		min !== void 0 ? `.min(${min})` : "",
+		max !== void 0 ? `.max(${max})` : "",
+		pattern !== void 0 ? `.regex(${toRegExpString(pattern, regexFunc(regexType))})` : ""
+	].join("");
+}
+/**
+* Build `.check(z.minimum(), z.maximum())` for `zod/mini` numeric constraints.
+*/
+function numberChecksMini({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }) {
+	const checks = [];
+	if (min !== void 0) checks.push(`z.minimum(${min})`);
+	if (max !== void 0) checks.push(`z.maximum(${max})`);
+	if (exclusiveMinimum !== void 0) checks.push(`z.minimum(${exclusiveMinimum}, { exclusive: true })`);
+	if (exclusiveMaximum !== void 0) checks.push(`z.maximum(${exclusiveMaximum}, { exclusive: true })`);
+	if (multipleOf !== void 0) checks.push(`z.multipleOf(${multipleOf})`);
+	return checks.length ? `.check(${checks.join(", ")})` : "";
+}
+/**
+* Build `.check(z.minLength(), z.maxLength(), z.regex())` for `zod/mini` length constraints.
+*/
+function lengthChecksMini({ min, max, pattern, regexType }) {
+	const checks = [];
+	if (min !== void 0) checks.push(`z.minLength(${min})`);
+	if (max !== void 0) checks.push(`z.maxLength(${max})`);
+	if (pattern !== void 0) checks.push(`z.regex(${toRegExpString(pattern, regexFunc(regexType))})`);
+	return checks.length ? `.check(${checks.join(", ")})` : "";
+}
+/**
+* Apply nullable / optional / nullish modifiers, an optional `.describe()` call, and an
+* optional `.meta({ examples })` call to a schema value string using the chainable Zod v4 API.
+*/
+function applyModifiers({ value, schema, nullable, optional, nullish, defaultValue, description, examples }) {
+	const withModifier = (() => {
+		if (nullish || nullable && optional) return `${value}.nullish()`;
+		if (optional) return `${value}.optional()`;
+		if (nullable) return `${value}.nullable()`;
+		return value;
+	})();
+	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
+	const withDefault = literal !== null ? `${withModifier}.default(${literal})` : withModifier;
+	const withDescription = description ? `${withDefault}.describe(${stringify(description)})` : withDefault;
+	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map(formatDefault).join(", ")}] })` : withDescription;
+}
+function modifierDepth(schema) {
+	if (schema.nullish || schema.nullable && schema.optional) return 2;
+	if (schema.nullable || schema.optional) return 1;
+	return 0;
+}
+/**
+* Build the `.unwrap()` chain to insert before `.omit()` when the schema is a `$ref`.
+*
+* A `$ref` resolves to a named schema variable that already carries its own `.nullable()` /
+* `.optional()` / `.nullish()` / `.default()` wrappers. `.omit()` lives on the inner `ZodObject`,
+* not on those `ZodNullable` / `ZodOptional` / `ZodDefault` wrappers, so the omit has to unwrap
+* down to the object first. This mirrors plugin-ts emitting `Omit<NonNullable<T>, …>`. Inline
+* objects need no unwrap because the printer adds their modifiers after `.omit()`.
+*/
+function omitUnwrapChain(node) {
+	const ref = kubb_kit.ast.narrowSchema(node, "ref");
+	if (!ref) return "";
+	const target = ref.schema ?? ref;
+	const depth = modifierDepth(target) + (target.default !== void 0 ? 1 : 0);
+	return ".unwrap()".repeat(depth);
+}
+/**
+* Apply nullable / optional / nullish modifiers using the functional `zod/mini` API
+* (`z.nullable()`, `z.optional()`, `z.nullish()`).
+*/
+function applyMiniModifiers({ value, schema, nullable, optional, nullish, defaultValue }) {
+	const withModifier = (() => {
+		if (nullish) return `z.nullish(${value})`;
+		const withNullable = nullable ? `z.nullable(${value})` : value;
+		return optional ? `z.optional(${withNullable})` : withNullable;
+	})();
+	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 kubb_kit.ast.factory.createSchema({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: param.schema
+		}))
+	});
+}
+//#endregion
+//#region src/printers/printerZod.ts
+function strictOneOfMember$1(member, node, cyclicSchemas) {
+	if (node.type === "object" && node.additionalProperties === void 0) return `${member}.strict()`;
+	if (node.type === "ref") {
+		if (member.startsWith("z.lazy(")) return member;
+		const refName = kubb_kit.ast.resolveRefName(node);
+		if (refName && cyclicSchemas?.has(refName)) return member;
+		const schema = (0, kubb_kit.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()`;
+	}
+	return member;
+}
+__name(strictOneOfMember$1, "strictOneOfMember");
+function getMemberConstraint({ member, regexType }) {
+	if (member.primitive === "string") return lengthConstraints({
+		...kubb_kit.ast.narrowSchema(member, "string") ?? {},
+		regexType
+	}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberConstraints(kubb_kit.ast.narrowSchema(member, "number") ?? kubb_kit.ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthConstraints({
+		...kubb_kit.ast.narrowSchema(member, "array") ?? {},
+		regexType
+	}) || void 0;
+}
+/**
+* Builds the `{ key: value, … }` shape for an object node, shared by the `z.object(...)` and
+* `.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodObjectShape(ctx, node) {
+	const objectNode = kubb_kit.ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && (0, kubb_kit.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;
+		const baseOutput = ctx.transform(schema) ?? ctx.transform(kubb_kit.ast.factory.createSchema({ type: "unknown" }));
+		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
+		return baseOutput;
+	}).map(({ name: propName, property, output: baseOutput }) => {
+		const { schema } = property;
+		const meta = (0, kubb_kit.syncSchemaRef)(schema);
+		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
+		const value = applyModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default,
+			description: descriptionToApply,
+			examples: meta.examples
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
+/**
+* Zod v4 printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a Zod v4 code string using the chainable API
+* (`.optional()`, `.nullable()`, `.omit()`, etc.). For improved tree-shaking, see {@link printerZodMini}.
+*
+* @example Chainable API
+* ```ts
+* const printer = printerZod({ coercion: false })
+* const code = printer.print(stringNode) // "z.string()"
+* ```
+*/
+const printerZod = kubb_kit.ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
+	return {
+		name: "zod",
+		options,
+		nodes: {
+			any: () => "z.any()",
+			unknown: () => "z.unknown()",
+			void: () => "z.void()",
+			never: () => "z.never()",
+			boolean: () => "z.boolean()",
+			null: () => "z.null()",
+			string(node) {
+				return `${shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()"}${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			number(node) {
+				return `${shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.number()" : "z.number()"}${numberConstraints(node)}`;
+			},
+			integer(node) {
+				return `${shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.number().int()" : "z.int()"}${numberConstraints(node)}`;
+			},
+			bigint() {
+				return shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.bigint()" : "z.bigint()";
+			},
+			date(node) {
+				const codec = getCodec(node);
+				if (codec) {
+					if (this.options.direction === "input") return codec.encode(node);
+					return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : codec.decode(node);
+				}
+				return "z.iso.date()";
+			},
+			datetime(node) {
+				const offset = node.offset || this.options.dateType === "stringOffset";
+				const local = node.local || this.options.dateType === "stringLocal";
+				if (offset) return "z.iso.datetime({ offset: true })";
+				if (local) return "z.iso.datetime({ local: true })";
+				return "z.iso.datetime()";
+			},
+			time(node) {
+				if (node.representation === "string") return "z.iso.time()";
+				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+			},
+			uuid(node) {
+				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			email(node) {
+				return `z.email()${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			url(node) {
+				return `z.url()${lengthConstraints({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			ipv4: () => "z.ipv4()",
+			ipv6: () => "z.ipv6()",
+			blob: () => "z.instanceof(File)",
+			enum(node) {
+				const nonNullValues = (node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []).filter((v) => v !== null);
+				if (node.namedEnumValues?.length) {
+					const literals = nonNullValues.map((v) => `z.literal(${formatLiteral(v)})`);
+					if (literals.length === 1) return literals[0];
+					return `z.union([${literals.join(", ")}])`;
+				}
+				return buildEnum(nonNullValues);
+			},
+			ref(node) {
+				if (!node.name) return null;
+				const refName = kubb_kit.ast.resolveRefName(node);
+				if (!refName) return null;
+				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
+				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.schema.inputName(refName) ?? refName : this.options.resolver?.name(refName) ?? refName : node.name;
+				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodObjectShape(this, node)})`;
+				return (() => {
+					const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
+					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(kubb_kit.ast.factory.createSchema({ type: "unknown" }))})`;
+					if (node.additionalProperties === false && patterns.length === 0) return `${objectBase}.strict()`;
+					if (patterns.length > 0) {
+						const values = patterns.map(([, valueSchema]) => {
+							const valueType = this.transform(valueSchema) ?? this.transform(kubb_kit.ast.factory.createSchema({ type: "unknown" }));
+							return valueSchema.nullable ? `${valueType}.nullable()` : valueType;
+						});
+						const distinct = [...new Set(values)];
+						const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
+						if (entries.length > 0) return `${objectBase}.catchall(${value})`;
+						return `z.record(${patternKeySchema({
+							patterns: patterns.map(([pattern]) => pattern),
+							regexType: this.options.regexType
+						})}, ${value})`;
+					}
+					return objectBase;
+				})();
+			},
+			array(node) {
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(kubb_kit.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(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+			},
+			union(node) {
+				const nodeMembers = node.members ?? [];
+				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));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
+			},
+			intersection(node) {
+				const members = node.members ?? [];
+				if (members.length === 0) return "";
+				const [first, ...rest] = members;
+				if (!first) return "";
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `${acc}.extend(${buildZodObjectShape(this, member)})`, firstBase);
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraint({
+						member,
+						regexType: this.options.regexType
+					});
+					if (constraint) return acc + constraint;
+					const transformed = this.transform(member);
+					return transformed ? `${acc}.and(${transformed})` : acc;
+				}, firstBase);
 			}
-			return node_path.default.resolve(root, output.path, baseName);
 		},
-		resolveName(name, type) {
-			let resolvedName = camelCase(name, {
-				suffix: type ? "schema" : void 0,
-				isFile: type === "file"
+		overrides: options.nodes,
+		print(node) {
+			const { keysToOmit } = this.options;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = (0, kubb_kit.syncSchemaRef)(node);
+			return applyModifiers({
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const unwrap = omitUnwrapChain(node);
+					const omit = `.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}${unwrap}${omit})`;
+					return `${transformed}${unwrap}${omit}`;
+				})(),
+				schema: node,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default,
+				description: meta.description,
+				examples: meta.examples
 			});
-			if (type === "type") resolvedName = pascalCase(resolvedName);
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
+		}
+	};
+});
+//#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, regexType }) {
+	if (member.primitive === "string") return lengthChecksMini({
+		...kubb_kit.ast.narrowSchema(member, "string") ?? {},
+		regexType
+	}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numberChecksMini(kubb_kit.ast.narrowSchema(member, "number") ?? kubb_kit.ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "array") return lengthChecksMini({
+		...kubb_kit.ast.narrowSchema(member, "array") ?? {},
+		regexType
+	}) || void 0;
+}
+/**
+* Builds the `{ key: value, … }` shape for an object node with the functional `zod/mini` modifiers,
+* shared by the `z.object(...)` and `z.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodMiniObjectShape(ctx, node) {
+	const objectNode = kubb_kit.ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && (0, kubb_kit.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;
+		const baseOutput = ctx.transform(schema) ?? ctx.transform(kubb_kit.ast.factory.createSchema({ type: "unknown" }));
+		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
+		return baseOutput;
+	}).map(({ name: propName, property, output: baseOutput }) => {
+		const { schema } = property;
+		const meta = (0, kubb_kit.syncSchemaRef)(schema);
+		const value = applyMiniModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
+/**
+* Zod v4 Mini printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a Zod v4 code string using the functional API
+* (`z.optional(z.string())`) for improved tree-shaking. See {@link printerZod} for the chainable API.
+*
+* @example Functional Mini API
+* ```ts
+* const printer = printerZodMini({})
+* const code = printer.print(optionalStringNode) // "z.optional(z.string())"
+* ```
+*/
+const printerZodMini = kubb_kit.ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
+	return {
+		name: "zod-mini",
+		options,
+		nodes: {
+			any: () => "z.any()",
+			unknown: () => "z.unknown()",
+			void: () => "z.void()",
+			never: () => "z.never()",
+			boolean: () => "z.boolean()",
+			null: () => "z.null()",
+			string(node) {
+				return `z.string()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			number(node) {
+				return `z.number()${numberChecksMini(node)}`;
+			},
+			integer(node) {
+				return `z.int()${numberChecksMini(node)}`;
+			},
+			bigint(node) {
+				return `z.bigint()${numberChecksMini(node)}`;
+			},
+			date(node) {
+				if (node.representation === "string") return "z.iso.date()";
+				return "z.date()";
+			},
+			datetime() {
+				return "z.string()";
+			},
+			time(node) {
+				if (node.representation === "string") return "z.iso.time()";
+				return "z.date()";
+			},
+			uuid(node) {
+				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			email(node) {
+				return `z.email()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			url(node) {
+				return `z.url()${lengthChecksMini({
+					...node,
+					regexType: this.options.regexType
+				})}`;
+			},
+			ipv4: () => "z.ipv4()",
+			ipv6: () => "z.ipv6()",
+			blob: () => "z.instanceof(File)",
+			enum(node) {
+				const nonNullValues = (node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? []).filter((v) => v !== null);
+				if (node.namedEnumValues?.length) {
+					const literals = nonNullValues.map((v) => `z.literal(${formatLiteral(v)})`);
+					if (literals.length === 1) return literals[0];
+					return `z.union([${literals.join(", ")}])`;
+				}
+				return buildEnum(nonNullValues);
+			},
+			ref(node) {
+				if (!node.name) return null;
+				const refName = kubb_kit.ast.resolveRefName(node);
+				if (!refName) return null;
+				const resolvedName = node.ref ? this.options.resolver?.name(refName) ?? refName : node.name;
+				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodMiniObjectShape(this, node)})`;
+				const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
+				if (node.additionalProperties && node.additionalProperties !== true) {
+					const catchallType = this.transform(node.additionalProperties);
+					return catchallType ? `z.catchall(${objectBase}, ${catchallType})` : objectBase;
+				}
+				if (node.additionalProperties === true) return `z.catchall(${objectBase}, ${this.transform(kubb_kit.ast.factory.createSchema({ type: "unknown" }))})`;
+				if (node.additionalProperties === false && patterns.length === 0) return objectBase.replace(/^z\.object\(/, "z.strictObject(");
+				if (patterns.length > 0) {
+					const values = patterns.map(([, valueSchema]) => {
+						const valueType = this.transform(valueSchema) ?? this.transform(kubb_kit.ast.factory.createSchema({ type: "unknown" }));
+						return valueSchema.nullable ? `z.nullable(${valueType})` : valueType;
+					});
+					const distinct = [...new Set(values)];
+					const value = distinct.length === 1 ? distinct[0] : `z.union([${distinct.join(", ")}])`;
+					if (entries.length > 0) return `z.catchall(${objectBase}, ${value})`;
+					return `z.record(${patternKeySchemaMini({
+						patterns: patterns.map(([pattern]) => pattern),
+						regexType: this.options.regexType
+					})}, ${value})`;
+				}
+				return objectBase;
+			},
+			array(node) {
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(kubb_kit.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(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+			},
+			union(node) {
+				const nodeMembers = node.members ?? [];
+				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));
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
+			},
+			intersection(node) {
+				const members = node.members ?? [];
+				if (members.length === 0) return "";
+				const [first, ...rest] = members;
+				if (!first) return "";
+				const firstBase = this.transform(first);
+				if (!firstBase) return "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `z.extend(${acc}, ${buildZodMiniObjectShape(this, member)})`, firstBase);
+				return rest.reduce((acc, member) => {
+					const constraint = getMemberConstraintMini({
+						member,
+						regexType: this.options.regexType
+					});
+					if (constraint) return acc + constraint;
+					const transformed = this.transform(member);
+					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
+				}, firstBase);
+			}
 		},
-		async install() {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			const mode = (0, _kubb_core.getMode)(node_path.default.resolve(root, output.path));
-			const oas = await this.getOas();
-			if (this.plugin.options.typed && this.plugin.options.version === "3") await this.addFile({
-				baseName: "ToZod.ts",
-				path: node_path.default.resolve(root, ".kubb/ToZod.ts"),
-				sources: [{
-					name: "ToZod",
-					value: require_templates_ToZod_source.source
-				}],
-				imports: [],
-				exports: []
+		overrides: options.nodes,
+		print(node) {
+			const { keysToOmit } = this.options;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = (0, kubb_kit.syncSchemaRef)(node);
+			return applyMiniModifiers({
+				value: (() => {
+					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
+					const unwrap = omitUnwrapChain(node);
+					const omit = `.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+					const lazyMatch = transformed.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+					if (lazyMatch) return `z.lazy(() => ${lazyMatch[1]}${unwrap}${omit})`;
+					return `${transformed}${unwrap}${omit}`;
+				})(),
+				schema: node,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default
 			});
-			const schemaFiles = await new _kubb_plugin_oas.SchemaGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				include: void 0,
-				override,
-				mode,
-				output: output.path
-			}).build(...generators);
-			await this.upsertFile(...schemaFiles);
-			const operationFiles = await new _kubb_plugin_oas.OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				exclude,
-				include,
-				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...operationFiles);
-			const barrelFiles = await (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
-				type: output.barrelType ?? "named",
+		}
+	};
+});
+//#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, and `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.regexType === params.regexType && cached.dateType === params.dateType && cached.nodes === params.nodes) return {
+		output: cached.output,
+		input: cached.input
+	};
+	const output = printerZod({
+		...params,
+		resolver,
+		direction: "output"
+	});
+	const input = printerZod({
+		...params,
+		resolver,
+		direction: "input"
+	});
+	zodPrinterCache.set(resolver, {
+		output,
+		input,
+		coercion: params.coercion,
+		guidType: params.guidType,
+		regexType: params.regexType,
+		dateType: params.dateType,
+		nodes: params.nodes
+	});
+	return {
+		output,
+		input
+	};
+}
+function getMiniPrinter(resolver, params) {
+	const cached = zodMiniPrinterCache.get(resolver);
+	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.nodes === params.nodes) return cached.printer;
+	const p = printerZodMini({
+		...params,
+		resolver
+	});
+	zodMiniPrinterCache.set(resolver, {
+		printer: p,
+		guidType: params.guidType,
+		regexType: params.regexType,
+		nodes: params.nodes
+	});
+	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 = (0, kubb_kit.defineGenerator)({
+	name: "zod",
+	renderer: kubb_jsx.jsxRenderer,
+	schema(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
+		const dateType = getOasAdapter(adapter).options.dateType;
+		if (!node.name) return;
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const hasCodec = !mini && containsCodec(node);
+		const codecRefNames = new Set(hasCodec ? collectCodecRefNames(node) : []);
+		const importEntries = resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
+			name: [resolver.schema.inputName(schemaName)],
+			path: resolver.file({
+				name: schemaName,
+				extname: ".ts",
 				root,
 				output,
-				meta: { pluginName: this.plugin.name }
+				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.name(node.name),
+			file: resolver.file({
+				name: node.name,
+				extname: ".ts",
+				root,
+				output,
+				group: group ?? void 0
+			})
+		};
+		const inferTypeName = inferred ? resolver.schema.typeName(node.name) : null;
+		const stdPrinters = mini ? null : getStdPrinters(resolver, {
+			coercion,
+			guidType,
+			regexType,
+			dateType,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		});
+		const schemaPrinter = mini ? getMiniPrinter(resolver, {
+			guidType,
+			regexType,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		}) : stdPrinters.output;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					node.name,
+					imp.path,
+					imp.name
+				].join("-"))),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+					name: meta.name,
+					node,
+					printer: schemaPrinter,
+					inferTypeName,
+					cyclic: cyclicSchemas.has(node.name)
+				}),
+				hasCodec && stdPrinters && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+					name: resolver.schema.inputName(node.name),
+					node,
+					printer: stdPrinters.input,
+					inferTypeName: inferred ? resolver.schema.inputTypeName(node.name) : null,
+					cyclic: cyclicSchemas.has(node.name)
+				})
+			]
+		});
+	},
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { adapter, config, resolver, root } = ctx;
+		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 meta = { file: resolver.file({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path,
+			root,
+			output,
+			group: group ?? void 0
+		}) };
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
+			if (!schema) return null;
+			const inferTypeName = inferred ? resolver.schema.type(name) : null;
+			const codecRefNames = direction === "input" && !mini ? new Set(collectCodecRefNames(schema)) : null;
+			const imports = resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0,
+				name: (schemaName) => codecRefNames?.has(schemaName) ? resolver.schema.inputName(schemaName) : resolver.name(schemaName)
+			});
+			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
+				guidType,
+				regexType,
+				resolver,
+				keysToOmit,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : getMiniPrinter(resolver, {
+				guidType,
+				regexType,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : keysToOmit?.length ? printerZod({
+				coercion,
+				guidType,
+				regexType,
+				dateType,
+				resolver,
+				keysToOmit,
+				cyclicSchemas,
+				nodes: printer?.nodes,
+				direction
+			}) : getStdPrinters(resolver, {
+				coercion,
+				guidType,
+				regexType,
+				dateType,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			})[direction];
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name
+			}, [
+				name,
+				imp.path,
+				imp.name
+			].join("-"))), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+				name,
+				node: schema,
+				printer: schemaPrinter,
+				inferTypeName,
+				cyclic: false
+			})] });
+		}
+		function buildContentTypeVariants(entries, baseName, decorate, direction) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = kubb_kit.ast.factory.createSchema({
+				type: "union",
+				members: variants.map((variant) => kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.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
+			})] });
+		}
+		function buildResponseUnion({ responses, name, fallbackUnknown }) {
+			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map((refName) => resolver.name(refName)) : []))).has(name)) return null;
+			const members = responses.map((res) => kubb_kit.ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.status(node, res.statusCode)
+			}));
+			if (fallbackUnknown && members.length === 0) return renderSchemaEntry({
+				schema: kubb_kit.ast.factory.createSchema({ type: "unknown" }),
+				name
+			});
+			return renderSchemaEntry({
+				schema: members.length === 1 ? members[0] : kubb_kit.ast.factory.createSchema({
+					type: "union",
+					members
+				}),
+				name
+			});
+		}
+		const paramSchemas = node.parameters.map((param) => renderSchemaEntry({
+			schema: param.schema,
+			name: resolver.param.name(node, param),
+			direction: "input"
+		}));
+		const responseSchemas = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.response.status(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaEntry({
+				schema: primary?.schema ?? null,
+				name: resolver.response.status(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
 			});
-			await this.upsertFile(...barrelFiles);
+		});
+		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+		const successResponsesWithSchema = getSuccessResponses(responsesWithSchema);
+		const responseUnionSchema = responsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: successResponsesWithSchema,
+			name: resolver.response.response(node),
+			fallbackUnknown: true
+		}) : null;
+		const errorResponsesWithSchema = responsesWithSchema.filter((res) => !isSuccessStatusCode(res.statusCode));
+		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: errorResponsesWithSchema,
+			name: resolver.response.error(node),
+			fallbackUnknown: false
+		}) : 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.response.body(node),
+					keysToOmit: entry.keysToOmit,
+					direction: "input"
+				});
+			}
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({
+				...schema,
+				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__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				paramSchemas,
+				responseSchemas,
+				responseUnionSchema,
+				errorUnionSchema,
+				requestSchema,
+				paramGroupSchemas,
+				optionsSchema
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverZod.ts
+/**
+* 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
+* with a `SchemaType` suffix (`PetSchemaType`), so the value and the type
+* never share an identifier even when the schema name is all-uppercase.
+*
+* @example Resolve schema and type names
+* ```ts
+* import { resolverZod } from '@kubb/plugin-zod'
+*
+* resolverZod.name('list pets')          // 'listPetsSchema'
+* resolverZod.schema.typeName('pet')     // 'PetSchemaType'
+* ```
+*/
+const resolverZod = (0, kubb_kit.createResolver)({
+	pluginName: "plugin-zod",
+	name(name) {
+		return ensureValidVarName(camelCase(name, { suffix: "schema" }));
+	},
+	file: createCasedFile((part) => camelCase(part, { suffix: "schema" })),
+	schema: {
+		typeName(name) {
+			return ensureValidVarName(pascalCase(name, { suffix: "schema type" }));
+		},
+		type(name) {
+			return ensureValidVarName(pascalCase(name, { suffix: "type" }));
+		},
+		inputName(name) {
+			return this.name(`${name} input`);
+		},
+		inputTypeName(name) {
+			return this.schema.typeName(`${name} input`);
 		}
+	},
+	param: createOperationParamResolver(),
+	response: {
+		...createOperationResponseResolver(),
+		error(node) {
+			return this.name(`${node.operationId} Error`);
+		},
+		options(node) {
+			return this.schema.type(this.name(`${node.operationId} Options`));
+		}
+	}
+});
+//#endregion
+//#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
+const pluginZodName = "plugin-zod";
+/**
+* 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-axios` or
+* `@kubb/plugin-fetch` and set the client's `validator: 'zod'` to validate every response
+* automatically.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginZod } from '@kubb/plugin-zod'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginZod({
+*       output: { path: './zod' },
+*       inferred: true,
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginZod = (0, kubb_kit.definePlugin)((options) => {
+	const { output = {
+		path: "zod",
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, printer, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
+	return {
+		name: pluginZodName,
+		options,
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions({
+				output,
+				exclude,
+				include,
+				override,
+				group: groupConfig,
+				importPath,
+				coercion,
+				inferred,
+				guidType,
+				regexType,
+				mini,
+				printer
+			});
+			ctx.setResolver(userResolver ? kubb_kit.Resolver.merge(resolverZod, userResolver) : resolverZod);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(zodGenerator);
+		} }
 	};
 });
 //#endregion
+exports.default = pluginZod;
 exports.pluginZod = pluginZod;
 exports.pluginZodName = pluginZodName;
+exports.printerZod = printerZod;
+exports.printerZodMini = printerZodMini;
+exports.resolverZod = resolverZod;
+exports.zodGenerator = zodGenerator;
 
 //# sourceMappingURL=index.cjs.map