@kubb/plugin-zod 5.0.0-alpha.3 → 5.0.0-alpha.30

package/dist/index.cjs

@@ -1,12 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_components = require("./components-B7zUFnAm.cjs");
-const require_generators = require("./generators-CzSLRVqQ.cjs");
-const require_templates_ToZod_source = require("./templates/ToZod.source.cjs");
-let node_path = require("node:path");
-node_path = require_components.__toESM(node_path);
+//#endregion
+let _kubb_ast = require("@kubb/ast");
 let _kubb_core = require("@kubb/core");
-let _kubb_plugin_oas = require("@kubb/plugin-oas");
-let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let _kubb_react_fabric = require("@kubb/react-fabric");
+let _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -26,9 +23,12 @@ function toCamelOrPascal(text, pascal) {
 * 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.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
+	const parts = text.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 /**
@@ -62,117 +62,1636 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/string.ts
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* 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;
+}
+//#endregion
+//#region ../../internals/utils/src/object.ts
+/**
+* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+*
+* @example
+* stringify('hello')   // '"hello"'
+* stringify('"hello"') // '"hello"'
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "\"\"";
+	return JSON.stringify(trimQuotes(value.toString()));
+}
+/**
+* Converts a plain object into a multiline key-value string suitable for embedding in generated code.
+* Nested objects are recursively stringified with indentation.
+*
+* @example
+* stringifyObject({ foo: 'bar', nested: { a: 1 } })
+* // 'foo: bar,\nnested: {\n        a: 1\n      }'
+*/
+function stringifyObject(value) {
+	return Object.entries(value).map(([key, val]) => {
+		if (val !== null && typeof val === "object") return `${key}: {\n        ${stringifyObject(val)}\n      }`;
+		return `${key}: ${val}`;
+	}).filter(Boolean).join(",\n");
+}
+//#endregion
+//#region ../../internals/utils/src/regexp.ts
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as `^(?im)` prefixes are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* 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 src/components/Operations.tsx
+function Operations({ name, operations }) {
+	const operationsJSON = operations.reduce((prev, acc) => {
+		prev[`"${acc.node.operationId}"`] = acc.data;
+		return prev;
+	}, {});
+	const pathsJSON = operations.reduce((prev, acc) => {
+		prev[`"${acc.node.path}"`] = {
+			...prev[`"${acc.node.path}"`] ?? {},
+			[acc.node.method]: `operations["${acc.node.operationId}"]`
+		};
+		return prev;
+	}, {});
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [
+		/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+			name: "OperationSchema",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Type, {
+				name: "OperationSchema",
+				export: true,
+				children: `{
+  readonly request: z.ZodTypeAny | undefined;
+  readonly parameters: {
+        readonly path: z.ZodTypeAny | undefined;
+        readonly query: z.ZodTypeAny | undefined;
+        readonly header: z.ZodTypeAny | undefined;
+  };
+  readonly responses: {
+        readonly [status: number]: z.ZodTypeAny;
+        readonly default: z.ZodTypeAny;
+  };
+  readonly errors: {
+        readonly [status: number]: z.ZodTypeAny;
+  };
+}`
+			})
+		}),
+		/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+			name: "OperationsMap",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Type, {
+				name: "OperationsMap",
+				export: true,
+				children: "Record<string, OperationSchema>"
+			})
+		}),
+		/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Const, {
+				export: true,
+				name,
+				asConst: true,
+				children: `{${stringifyObject(operationsJSON)}}`
+			})
+		}),
+		/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+			name: "paths",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Const, {
+				export: true,
+				name: "paths",
+				asConst: true,
+				children: `{${stringifyObject(pathsJSON)}}`
+			})
+		})
+	] });
+}
+//#endregion
+//#region src/components/Zod.tsx
+function Zod({ name, node, printer, inferTypeName }) {
+	const output = printer.print(node);
+	if (!output) return;
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Const, {
+			export: true,
+			name,
+			children: output
+		})
+	}), inferTypeName && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+		name: inferTypeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.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 = 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];
+}
+/**
+* Collects all resolved schema names for an operation's parameters and responses
+* into a single lookup object, useful for building imports and type references.
+*/
+function buildSchemaNames(node, { params, resolver }) {
+	const pathParam = params.find((p) => p.in === "path");
+	const queryParam = params.find((p) => p.in === "query");
+	const headerParam = params.find((p) => p.in === "header");
+	const responses = {};
+	const errors = {};
+	for (const res of node.responses) {
+		const name = resolver.resolveResponseStatusName(node, res.statusCode);
+		const statusNum = Number(res.statusCode);
+		if (!Number.isNaN(statusNum)) {
+			responses[statusNum] = name;
+			if (statusNum >= 400) errors[statusNum] = name;
+		}
+	}
+	responses["default"] = resolver.resolveResponseName(node);
+	return {
+		request: node.requestBody?.schema ? resolver.resolveDataName(node) : void 0,
+		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
+		},
+		responses,
+		errors
+	};
+}
+/**
+* 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 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 `.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 }) {
+	return [
+		min !== void 0 ? `.min(${min})` : "",
+		max !== void 0 ? `.max(${max})` : "",
+		pattern !== void 0 ? `.regex(${toRegExpString(pattern, null)})` : ""
+	].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 }) {
+	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, null)})`);
+	return checks.length ? `.check(${checks.join(", ")})` : "";
+}
+/**
+* Apply nullable / optional / nullish modifiers and an optional `.describe()` call
+* 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;
+}
+/**
+* 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;
+}
+/**
+* Returns true when the schema tree contains a self-referential `$ref`
+* whose resolved name matches `schemaName`.
+*
+* A `visited` set prevents infinite recursion on circular schema graphs.
+*/
+function containsSelfRef(node, { schemaName, resolver, visited = /* @__PURE__ */ new Set() }) {
+	if (visited.has(node)) return false;
+	visited.add(node);
+	if (node.type === "ref" && node.ref) {
+		const rawName = (0, _kubb_ast.extractRefName)(node.ref) ?? node.name;
+		return (rawName ? resolver?.default(rawName, "function") ?? rawName : node.name) === schemaName;
+	}
+	if (node.type === "object") {
+		if (node.properties?.some((p) => containsSelfRef(p.schema, {
+			schemaName,
+			resolver,
+			visited
+		}))) return true;
+		if (node.additionalProperties && node.additionalProperties !== true) return containsSelfRef(node.additionalProperties, {
+			schemaName,
+			resolver,
+			visited
+		});
+		return false;
+	}
+	if (node.type === "array" || node.type === "tuple") return node.items?.some((item) => containsSelfRef(item, {
+		schemaName,
+		resolver,
+		visited
+	})) ?? false;
+	if (node.type === "union" || node.type === "intersection") return node.members?.some((m) => containsSelfRef(m, {
+		schemaName,
+		resolver,
+		visited
+	})) ?? false;
+	return false;
+}
+//#endregion
+//#region src/printers/printerZod.ts
+/**
+* Zod v4 printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a **standard** Zod v4 code string
+* using the chainable method API (`.optional()`, `.nullable()`, etc.).
+*
+* For the `zod/mini` functional API, see {@link printerZodMini}.
+*
+* @example
+* ```ts
+* const printer = printerZod({ coercion: false })
+* const code = printer.print(stringSchemaNode) // "z.string()"
+* ```
+*/
+const printerZod = (0, _kubb_core.definePrinter)((options) => {
+	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)}`;
+			},
+			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) {
+				if (node.representation === "string") return "z.iso.date()";
+				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+			},
+			datetime(node) {
+				if (node.offset) return "z.iso.datetime({ offset: true })";
+				if (node.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)}`;
+			},
+			email(node) {
+				return `z.email()${lengthConstraints(node)}`;
+			},
+			url(node) {
+				return `z.url()${lengthConstraints(node)}`;
+			},
+			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 `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
+			},
+			ref(node) {
+				if (!node.name) return void 0;
+				const refName = node.ref ? (0, _kubb_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.schemaName != null && resolvedName === this.options.schemaName) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				let result = `z.object({\n    ${node.properties.map((prop) => {
+					const { name: propName, schema } = prop;
+					const meta = (0, _kubb_ast.syncSchemaRef)(schema);
+					const isNullable = meta.nullable;
+					const isOptional = schema.optional;
+					const isNullish = schema.nullish;
+					const hasSelfRef = this.options.schemaName != null && containsSelfRef(schema, {
+						schemaName: this.options.schemaName,
+						resolver: this.options.resolver
+					});
+					const baseOutput = this.transform(schema) ?? this.transform((0, _kubb_ast.createSchema)({ type: "unknown" }));
+					const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName) : baseOutput;
+					const value = applyModifiers({
+						value: this.options.wrapOutput ? this.options.wrapOutput({
+							output: resolvedOutput,
+							schema
+						}) || resolvedOutput : resolvedOutput,
+						nullable: isNullable,
+						optional: isOptional,
+						nullish: isNullish,
+						defaultValue: meta.default,
+						description: meta.description
+					});
+					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((0, _kubb_ast.createSchema)({ type: "unknown" }))})`;
+				else if (node.additionalProperties === false) result += ".strict()";
+				return result;
+			},
+			array(node) {
+				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform((0, _kubb_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;
+			},
+			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);
+				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(", ")}])`;
+				return `z.union([${members.join(", ")}])`;
+			},
+			intersection(node) {
+				const members = node.members ?? [];
+				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((0, _kubb_ast.narrowSchema)(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberConstraints((0, _kubb_ast.narrowSchema)(member, "number") ?? (0, _kubb_ast.narrowSchema)(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthConstraints((0, _kubb_ast.narrowSchema)(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const transformed = this.transform(member);
+					if (transformed) base = `${base}.and(${transformed})`;
+				}
+				return base;
+			},
+			...options.nodes
+		},
+		print(node) {
+			const { keysToOmit } = this.options;
+			let base = this.transform(node);
+			if (!base) return null;
+			const meta = (0, _kubb_ast.syncSchemaRef)(node);
+			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+			return applyModifiers({
+				value: base,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default,
+				description: meta.description
+			});
+		}
+	};
+});
+//#endregion
+//#region src/printers/printerZodMini.ts
+/**
+* Zod v4 **Mini** printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a Zod v4 Mini code string using the
+* functional API (`z.optional(z.string())`) for better tree-shaking.
+*
+* For the standard chainable API, see {@link printerZod}.
+*
+* @example
+* ```ts
+* const printer = printerZodMini({})
+* const code = printer.print(optionalStringNode) // "z.optional(z.string())"
+* ```
+*/
+const printerZodMini = (0, _kubb_core.definePrinter)((options) => {
+	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)}`;
+			},
+			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)}`;
+			},
+			email(node) {
+				return `z.email()${lengthChecksMini(node)}`;
+			},
+			url(node) {
+				return `z.url()${lengthChecksMini(node)}`;
+			},
+			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 `z.enum([${nonNullValues.map(formatLiteral).join(", ")}])`;
+			},
+			ref(node) {
+				if (!node.name) return void 0;
+				const refName = node.ref ? (0, _kubb_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.schemaName != null && resolvedName === this.options.schemaName) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				return `z.object({\n    ${node.properties.map((prop) => {
+					const { name: propName, schema } = prop;
+					const meta = (0, _kubb_ast.syncSchemaRef)(schema);
+					const isNullable = meta.nullable;
+					const isOptional = schema.optional;
+					const isNullish = schema.nullish;
+					const hasSelfRef = this.options.schemaName != null && containsSelfRef(schema, {
+						schemaName: this.options.schemaName,
+						resolver: this.options.resolver
+					});
+					const baseOutput = this.transform(schema) ?? this.transform((0, _kubb_ast.createSchema)({ type: "unknown" }));
+					const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName) : baseOutput;
+					const value = applyMiniModifiers({
+						value: this.options.wrapOutput ? this.options.wrapOutput({
+							output: resolvedOutput,
+							schema
+						}) || resolvedOutput : resolvedOutput,
+						nullable: isNullable,
+						optional: isOptional,
+						nullish: isNullish,
+						defaultValue: meta.default
+					});
+					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
+					return `"${propName}": ${value}`;
+				}).join(",\n    ")}\n    })`;
+			},
+			array(node) {
+				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform((0, _kubb_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;
+			},
+			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);
+				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(", ")}])`;
+				return `z.union([${members.join(", ")}])`;
+			},
+			intersection(node) {
+				const members = node.members ?? [];
+				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((0, _kubb_ast.narrowSchema)(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberChecksMini((0, _kubb_ast.narrowSchema)(member, "number") ?? (0, _kubb_ast.narrowSchema)(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthChecksMini((0, _kubb_ast.narrowSchema)(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const transformed = this.transform(member);
+					if (transformed) base = `z.intersection(${base}, ${transformed})`;
+				}
+				return base;
+			},
+			...options.nodes
+		},
+		print(node) {
+			const { keysToOmit } = this.options;
+			let base = this.transform(node);
+			if (!base) return null;
+			const meta = (0, _kubb_ast.syncSchemaRef)(node);
+			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+			return applyMiniModifiers({
+				value: base,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default
+			});
+		}
+	};
+});
+//#endregion
+//#region src/generators/zodGenerator.tsx
+const zodGenerator = (0, _kubb_core.defineGenerator)({
+	name: "zod",
+	schema(node, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options;
+		if (!node.name) return;
+		const mode = this.getMode(output);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const imports = adapter.getImports(node, (schemaName) => ({
+			name: resolver.resolveSchemaName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const meta = {
+			name: resolver.resolveSchemaName(node.name),
+			file: resolver.resolveFile({
+				name: node.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : void 0;
+		const schemaPrinter = mini ? printerZodMini({
+			guidType,
+			wrapOutput,
+			resolver,
+			schemaName: meta.name,
+			nodes: printer?.nodes
+		}) : printerZod({
+			coercion,
+			guidType,
+			wrapOutput,
+			resolver,
+			schemaName: meta.name,
+			nodes: printer?.nodes
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [node.name, imp.path].join("-"))),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Zod, {
+					name: meta.name,
+					node,
+					printer: schemaPrinter,
+					inferTypeName
+				})
+			]
+		});
+	},
+	operation(node, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options;
+		const mode = this.getMode(output);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const params = (0, _kubb_ast.caseParams)(node.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output,
+			group
+		}) };
+		function renderSchemaEntry({ schema, name, keysToOmit }) {
+			if (!schema) return null;
+			const inferTypeName = inferred ? resolver.resolveTypeName(name) : void 0;
+			const imports = adapter.getImports(schema, (schemaName) => ({
+				name: resolver.resolveSchemaName(schemaName),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			const schemaPrinter = mini ? printerZodMini({
+				guidType,
+				wrapOutput,
+				resolver,
+				schemaName: name,
+				keysToOmit,
+				nodes: printer?.nodes
+			}) : printerZod({
+				coercion,
+				guidType,
+				wrapOutput,
+				resolver,
+				schemaName: name,
+				keysToOmit,
+				nodes: printer?.nodes
+			});
+			return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name
+			}, [
+				name,
+				imp.path,
+				imp.name
+			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Zod, {
+				name,
+				node: schema,
+				printer: schemaPrinter,
+				inferTypeName
+			})] });
+		}
+		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
+		}));
+		const requestSchema = node.requestBody?.schema ? renderSchemaEntry({
+			schema: {
+				...node.requestBody.schema,
+				description: node.requestBody.description ?? node.requestBody.schema.description
+			},
+			name: resolver.resolveDataName(node),
+			keysToOmit: node.requestBody.keysToOmit
+		}) : null;
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				paramSchemas,
+				responseSchemas,
+				requestSchema
+			]
+		});
+	},
+	operations(nodes, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, importPath, group, operations, paramsCasing } = options;
+		if (!operations) return;
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const meta = { file: resolver.resolveFile({
+			name: "operations",
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group
+		}) };
+		const transformedOperations = nodes.map((node) => {
+			return {
+				node,
+				data: buildSchemaNames(node, {
+					params: (0, _kubb_ast.caseParams)(node.parameters, paramsCasing),
+					resolver
+				})
+			};
+		});
+		const imports = transformedOperations.flatMap(({ node, data }) => {
+			const names = [
+				data.request,
+				...Object.values(data.responses),
+				...Object.values(data.parameters)
+			].filter(Boolean);
+			const opFile = resolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			});
+			return names.map((name) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: [name],
+				root: meta.file.path,
+				path: opFile.path
+			}, [name, opFile.path].join("-")));
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					isTypeOnly: true,
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports,
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Operations, {
+					name: "operations",
+					operations: transformedOperations
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/zodGeneratorLegacy.tsx
+function buildGroupedParamsSchema({ params, optional }) {
+	return (0, _kubb_ast.createSchema)({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => {
+			return (0, _kubb_ast.createProperty)({
+				name: param.name,
+				required: param.required,
+				schema: param.schema
+			});
+		})
+	});
+}
+function buildLegacyResponsesSchemaNode(node, { resolver }) {
+	const isGet = node.method.toLowerCase() === "get";
+	const successResponses = node.responses.filter((res) => {
+		const code = Number(res.statusCode);
+		return !Number.isNaN(code) && code >= 200 && code < 300;
+	});
+	const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
+	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? (0, _kubb_ast.createSchema)({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	}) : (0, _kubb_ast.createSchema)({
+		type: "union",
+		members: successResponses.map((res) => (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : (0, _kubb_ast.createSchema)({ type: "any" });
+	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? (0, _kubb_ast.createSchema)({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
+	}) : (0, _kubb_ast.createSchema)({
+		type: "union",
+		members: errorResponses.map((res) => (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : (0, _kubb_ast.createSchema)({ type: "any" });
+	const properties = [(0, _kubb_ast.createProperty)({
+		name: "Response",
+		required: true,
+		schema: responseSchema
+	})];
+	if (!isGet && node.requestBody?.schema) properties.push((0, _kubb_ast.createProperty)({
+		name: "Request",
+		required: true,
+		schema: (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveDataName(node)
+		})
+	}));
+	const queryParam = node.parameters.find((p) => p.in === "query");
+	if (queryParam) properties.push((0, _kubb_ast.createProperty)({
+		name: "QueryParams",
+		required: true,
+		schema: (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveQueryParamsName(node, queryParam)
+		})
+	}));
+	const pathParam = node.parameters.find((p) => p.in === "path");
+	if (pathParam) properties.push((0, _kubb_ast.createProperty)({
+		name: "PathParams",
+		required: true,
+		schema: (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolvePathParamsName(node, pathParam)
+		})
+	}));
+	const headerParam = node.parameters.find((p) => p.in === "header");
+	if (headerParam) properties.push((0, _kubb_ast.createProperty)({
+		name: "HeaderParams",
+		required: true,
+		schema: (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveHeaderParamsName(node, headerParam)
+		})
+	}));
+	properties.push((0, _kubb_ast.createProperty)({
+		name: "Errors",
+		required: true,
+		schema: errorsSchema
+	}));
+	return (0, _kubb_ast.createSchema)({
+		type: "object",
+		primitive: "object",
+		properties
+	});
+}
+function buildLegacyResponseUnionSchemaNode(node, { resolver }) {
+	const successResponses = node.responses.filter((res) => {
+		const code = Number(res.statusCode);
+		return !Number.isNaN(code) && code >= 200 && code < 300;
+	});
+	if (successResponses.length === 0) return (0, _kubb_ast.createSchema)({ type: "any" });
+	if (successResponses.length === 1) return (0, _kubb_ast.createSchema)({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	});
+	return (0, _kubb_ast.createSchema)({
+		type: "union",
+		members: successResponses.map((res) => (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	});
+}
+function buildLegacySchemaNames(node, params, resolver) {
+	const pathParam = params.find((p) => p.in === "path");
+	const queryParam = params.find((p) => p.in === "query");
+	const headerParam = params.find((p) => p.in === "header");
+	const responses = {};
+	const errors = {};
+	for (const res of node.responses) {
+		const name = resolver.resolveResponseStatusName(node, res.statusCode);
+		const statusNum = Number(res.statusCode);
+		if (!Number.isNaN(statusNum)) {
+			responses[statusNum] = name;
+			if (statusNum >= 400) errors[statusNum] = name;
+		}
+	}
+	responses["default"] = resolver.resolveResponseName(node);
+	return {
+		request: node.requestBody?.schema ? resolver.resolveDataName(node) : void 0,
+		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
+		},
+		responses,
+		errors
+	};
+}
+const zodGeneratorLegacy = (0, _kubb_core.defineGenerator)({
+	name: "zod-legacy",
+	schema(node, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options;
+		if (!node.name) return;
+		const mode = this.getMode(output);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const imports = adapter.getImports(node, (schemaName) => ({
+			name: resolver.resolveSchemaName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : void 0;
+		const meta = {
+			name: resolver.resolveSchemaName(node.name),
+			file: resolver.resolveFile({
+				name: node.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		const schemaPrinter = mini ? printerZodMini({
+			guidType,
+			wrapOutput,
+			resolver,
+			schemaName: meta.name,
+			nodes: printer?.nodes
+		}) : printerZod({
+			coercion,
+			guidType,
+			wrapOutput,
+			resolver,
+			schemaName: meta.name,
+			nodes: printer?.nodes
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [node.name, imp.path].join("-"))),
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Zod, {
+					name: meta.name,
+					node,
+					printer: schemaPrinter,
+					inferTypeName
+				})
+			]
+		});
+	},
+	operation(node, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options;
+		const mode = this.getMode(output);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const params = (0, _kubb_ast.caseParams)(node.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output,
+			group
+		}) };
+		function renderSchemaEntry({ schema, name, keysToOmit }) {
+			if (!schema) return null;
+			const inferTypeName = inferred ? resolver.resolveTypeName(name) : void 0;
+			const imports = adapter.getImports(schema, (schemaName) => ({
+				name: resolver.resolveSchemaName(schemaName),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			const schemaPrinter = mini ? printerZodMini({
+				guidType,
+				wrapOutput,
+				resolver,
+				schemaName: name,
+				keysToOmit,
+				nodes: printer?.nodes
+			}) : printerZod({
+				coercion,
+				guidType,
+				wrapOutput,
+				resolver,
+				schemaName: name,
+				keysToOmit,
+				nodes: printer?.nodes
+			});
+			return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name
+			}, [
+				name,
+				imp.path,
+				imp.name
+			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Zod, {
+				name,
+				node: schema,
+				printer: schemaPrinter,
+				inferTypeName
+			})] });
+		}
+		const pathParams = params.filter((p) => p.in === "path");
+		const queryParams = params.filter((p) => p.in === "query");
+		const headerParams = params.filter((p) => p.in === "header");
+		const responseSchemas = node.responses.map((res) => {
+			const responseName = resolver.resolveResponseStatusName(node, res.statusCode);
+			return renderSchemaEntry({
+				schema: {
+					...res.schema,
+					description: res.description ?? res.schema.description
+				},
+				name: responseName,
+				keysToOmit: res.keysToOmit
+			});
+		});
+		const requestSchema = node.requestBody?.schema ? renderSchemaEntry({
+			schema: {
+				...node.requestBody.schema,
+				description: node.requestBody.description ?? node.requestBody.schema.description
+			},
+			name: resolver.resolveDataName(node),
+			keysToOmit: node.requestBody.keysToOmit
+		}) : null;
+		const legacyParamTypes = [
+			pathParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: pathParams,
+					optional: pathParams.every((p) => !p.required)
+				}),
+				name: resolver.resolvePathParamsName(node, pathParams[0])
+			}) : null,
+			queryParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: queryParams,
+					optional: queryParams.every((p) => !p.required)
+				}),
+				name: resolver.resolveQueryParamsName(node, queryParams[0])
+			}) : null,
+			headerParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: headerParams,
+					optional: headerParams.every((p) => !p.required)
+				}),
+				name: resolver.resolveHeaderParamsName(node, headerParams[0])
+			}) : null
+		];
+		const legacyResponsesSchema = renderSchemaEntry({
+			schema: buildLegacyResponsesSchemaNode(node, { resolver }),
+			name: resolver.resolveResponsesName(node)
+		});
+		const legacyResponseSchema = renderSchemaEntry({
+			schema: buildLegacyResponseUnionSchemaNode(node, { resolver }),
+			name: resolver.resolveResponseName(node)
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				legacyParamTypes,
+				responseSchemas,
+				requestSchema,
+				legacyResponseSchema,
+				legacyResponsesSchema
+			]
+		});
+	},
+	operations(nodes, options) {
+		const { adapter, config, resolver, root } = this;
+		const { output, importPath, group, operations, paramsCasing } = options;
+		if (!operations) return;
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const meta = { file: resolver.resolveFile({
+			name: "operations",
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group
+		}) };
+		const transformedOperations = nodes.map((node) => {
+			return {
+				node,
+				data: buildLegacySchemaNames(node, (0, _kubb_ast.caseParams)(node.parameters, paramsCasing), resolver)
+			};
+		});
+		const imports = transformedOperations.flatMap(({ node, data }) => {
+			const names = [
+				data.request,
+				...Object.values(data.responses),
+				...Object.values(data.parameters)
+			].filter(Boolean);
+			const opFile = resolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			});
+			return names.map((name) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+				name: [name],
+				root: meta.file.path,
+				path: opFile.path
+			}, [name, opFile.path].join("-")));
+		});
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
+					isTypeOnly: true,
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports,
+				/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Operations, {
+					name: "operations",
+					operations: transformedOperations
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region package.json
+var version = "5.0.0-alpha.30";
+//#endregion
+//#region src/resolvers/resolverZod.ts
+/**
+* Default resolver for `@kubb/plugin-zod`.
+*
+* Uses `camelCase` naming with a `Schema` suffix for function/type/const names.
+*
+* @example
+* ```ts
+* resolverZod.default('list pets', 'function') // → 'listPetsSchema'
+* resolverZod.default('Pet', 'file')           // → 'pet'
+* resolverZod.resolveName('list pets')          // → 'listPetsSchema'
+* ```
+*/
+const resolverZod = (0, _kubb_core.defineResolver)(() => {
+	return {
+		name: "default",
+		pluginName: "plugin-zod",
+		default(name, type) {
+			return camelCase(name, {
+				isFile: type === "file",
+				suffix: type ? "schema" : void 0
+			});
+		},
+		resolveSchemaName(name) {
+			return camelCase(name, { suffix: "schema" });
+		},
+		resolveSchemaTypeName(name) {
+			return pascalCase(name, { suffix: "schema" });
+		},
+		resolveTypeName(name) {
+			return pascalCase(name);
+		},
+		resolvePathName(name, type) {
+			return this.default(name, type);
+		},
+		resolveParamName(node, param) {
+			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
+		},
+		resolveResponseStatusName(node, statusCode) {
+			return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveDataName(node) {
+			return this.resolveSchemaName(`${node.operationId} Data`);
+		},
+		resolveResponsesName(node) {
+			return this.resolveSchemaName(`${node.operationId} Responses`);
+		},
+		resolveResponseName(node) {
+			return this.resolveSchemaName(`${node.operationId} Response`);
+		},
+		resolvePathParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		},
+		resolveQueryParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		},
+		resolveHeaderParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		}
+	};
+});
+//#endregion
+//#region src/resolvers/resolverZodLegacy.ts
+/**
+* Legacy resolver for `@kubb/plugin-zod` that reproduces the naming conventions
+* used in Kubb v4. Enable via `compatibilityPreset: 'kubbV4'`
+* (or by composing this resolver manually).
+*
+* Key differences from the default resolver:
+* - Response status types: `<operationId><StatusCode>Schema` (e.g. `createPets201Schema`) instead of `<operationId>Status201Schema`
+* - Default/error responses: `<operationId>ErrorSchema` instead of `<operationId>StatusDefaultSchema`
+* - Request body: `<operationId>MutationRequestSchema` (non-GET) / `<operationId>QueryRequestSchema` (GET)
+* - Combined responses type: `<operationId>MutationSchema` / `<operationId>QuerySchema`
+* - Response union: `<operationId>MutationResponseSchema` / `<operationId>QueryResponseSchema`
+*
+* @example
+* ```ts
+* import { resolverZodLegacy } from '@kubb/plugin-zod'
+*
+* resolverZodLegacy.resolveResponseStatusName(node, 201)  // → 'createPets201Schema'
+* resolverZodLegacy.resolveResponseStatusName(node, 'default')  // → 'createPetsErrorSchema'
+* resolverZodLegacy.resolveDataName(node)  // → 'createPetsMutationRequestSchema' (POST)
+* resolverZodLegacy.resolveResponsesName(node)  // → 'createPetsMutationSchema' (POST)
+* resolverZodLegacy.resolveResponseName(node)  // → 'createPetsMutationResponseSchema' (POST)
+* ```
+*/
+const resolverZodLegacy = (0, _kubb_core.defineResolver)(() => {
+	return {
+		...resolverZod,
+		pluginName: "plugin-zod",
+		resolveResponseStatusName(node, statusCode) {
+			if (statusCode === "default") return this.resolveSchemaName(`${node.operationId} Error`);
+			return this.resolveSchemaName(`${node.operationId} ${statusCode}`);
+		},
+		resolveDataName(node) {
+			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+			return this.resolveSchemaName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponsesName(node) {
+			const suffix = node.method === "GET" ? "Query" : "Mutation";
+			return this.resolveSchemaName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponseName(node) {
+			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+			return this.resolveSchemaName(`${node.operationId} ${suffix}`);
+		},
+		resolvePathParamsName(node, _param) {
+			return this.resolveSchemaName(`${node.operationId} PathParams`);
+		},
+		resolveQueryParamsName(node, _param) {
+			return this.resolveSchemaName(`${node.operationId} QueryParams`);
+		},
+		resolveHeaderParamsName(node, _param) {
+			return this.resolveSchemaName(`${node.operationId} HeaderParams`);
+		}
+	};
+});
+//#endregion
+//#region src/presets.ts
+/**
+* Built-in preset registry for `@kubb/plugin-zod`.
+*
+* - `default` — uses `resolverZod` and `zodGenerator` (current naming conventions).
+* - `kubbV4` — uses `resolverZodLegacy` and `zodGeneratorLegacy` (Kubb v4 naming conventions).
+*
+* Note: `printerZodMini` is selected at runtime by the generator when `mini: true` is set.
+*/
+const presets = (0, _kubb_core.definePresets)({
+	default: {
+		name: "default",
+		resolver: resolverZod,
+		generators: [zodGenerator],
+		printer: printerZod
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolver: resolverZodLegacy,
+		generators: [zodGeneratorLegacy],
+		printer: printerZod
+	}
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-zod`, used to identify the plugin in driver lookups and warnings.
+*/
 const pluginZodName = "plugin-zod";
-const pluginZod = (0, _kubb_core.definePlugin)((options) => {
+/**
+* The `@kubb/plugin-zod` plugin factory.
+*
+* Generates Zod validation schemas from an OpenAPI/AST `RootNode`.
+* Walks schemas and operations, delegates rendering to the active generators,
+* and writes barrel files based on `output.barrelType`.
+*
+* @example
+* ```ts
+* import { pluginZod } from '@kubb/plugin-zod'
+*
+* export default defineConfig({
+*   plugins: [pluginZod({ output: { path: '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" : new _kubb_core.PackageManager().isValidSync("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;
+	}, group, exclude = [], include, override = [], dateType = "string", typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, compatibilityPreset = "default", resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+	const preset = (0, _kubb_core.getPreset)({
+		preset: compatibilityPreset,
+		presets,
+		resolver: userResolver,
+		transformer: userTransformer,
+		generators: userGenerators
+	});
+	const mergedGenerator = (0, _kubb_core.mergeGenerators)(preset.generators ?? []);
+	let resolveNameWarning = false;
+	let resolvePathWarning = false;
 	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: {}
+		version,
+		get resolver() {
+			return preset.resolver;
 		},
-		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);
-			}
-			return node_path.default.resolve(root, output.path, baseName);
+		get transformer() {
+			return preset.transformer;
 		},
-		resolveName(name, type) {
-			let resolvedName = camelCase(name, {
-				suffix: type ? "schema" : void 0,
-				isFile: type === "file"
-			});
-			if (type === "type") resolvedName = pascalCase(resolvedName);
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		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: []
-			});
-			const schemaFiles = await new _kubb_plugin_oas.SchemaGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				pluginManager: this.pluginManager,
-				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,
-				pluginManager: this.pluginManager,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+		get options() {
+			return {
+				output,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...operationFiles);
-			const barrelFiles = await (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
+				group: group ? {
+					...group,
+					name: (ctx) => {
+						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+						return `${camelCase(ctx.group)}Controller`;
+					}
+				} : void 0,
+				dateType,
+				typed,
+				importPath,
+				coercion,
+				operations,
+				inferred,
+				guidType,
+				mini,
+				wrapOutput,
+				paramsCasing,
+				printer
+			};
+		},
+		resolvePath(baseName, pathMode, options) {
+			if (!resolvePathWarning) {
+				this.warn("Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead");
+				resolvePathWarning = true;
+			}
+			return this.plugin.resolver.resolvePath({
+				baseName,
+				pathMode,
+				tag: options?.group?.tag,
+				path: options?.group?.path
+			}, {
+				root: this.root,
 				output,
-				meta: { pluginName: this.plugin.name }
+				group: this.plugin.options.group
 			});
-			await this.upsertFile(...barrelFiles);
+		},
+		resolveName(name, type) {
+			if (!resolveNameWarning) {
+				this.warn("Do not use resolveName for pluginZod, use resolverZod.default instead");
+				resolveNameWarning = true;
+			}
+			return this.plugin.resolver.default(name, type);
+		},
+		async schema(node, options) {
+			return mergedGenerator.schema?.call(this, node, options);
+		},
+		async operation(node, options) {
+			return mergedGenerator.operation?.call(this, node, options);
+		},
+		async operations(nodes, options) {
+			return mergedGenerator.operations?.call(this, nodes, options);
+		},
+		async buildStart() {
+			await this.openInStudio({ ast: true });
 		}
 	};
 });
 //#endregion
 exports.pluginZod = pluginZod;
 exports.pluginZodName = pluginZodName;
+exports.printerZod = printerZod;
+exports.printerZodMini = printerZodMini;
+exports.resolverZod = resolverZod;
+exports.resolverZodLegacy = resolverZodLegacy;
+exports.zodGenerator = zodGenerator;
+exports.zodGeneratorLegacy = zodGeneratorLegacy;
 
 //# sourceMappingURL=index.cjs.map