@kubb/plugin-zod 5.0.0-alpha.24 → 5.0.0-alpha.25

package/dist/index.js

@@ -1,10 +1,9 @@
 import "./chunk--u3MIqq1.js";
-import { n as operationsGenerator, t as zodGenerator } from "./generators-maqx12yN.js";
-import { source } from "./templates/ToZod.source.js";
 import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode, satisfiesDependency } from "@kubb/core";
-import { OperationGenerator, SchemaGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { caseParams, composeTransformers, createProperty, createSchema, extractRefName, narrowSchema, syncSchemaRef, transform, walk } from "@kubb/ast";
+import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getBarrelFiles, getMode, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from "@kubb/core";
+import { Const, File, Type } from "@kubb/react-fabric";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -63,105 +62,1664 @@ 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__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(File.Source, {
+			name: "OperationSchema",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(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__ */ jsx(File.Source, {
+			name: "OperationsMap",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Type, {
+				name: "OperationsMap",
+				export: true,
+				children: "Record<string, OperationSchema>"
+			})
+		}),
+		/* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name,
+				asConst: true,
+				children: `{${stringifyObject(operationsJSON)}}`
+			})
+		}),
+		/* @__PURE__ */ jsx(File.Source, {
+			name: "paths",
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name: "paths",
+				asConst: true,
+				children: `{${stringifyObject(pathsJSON)}}`
+			})
+		})
+	] });
+}
+//#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 = 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 = 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 ? 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 = 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(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(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(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(narrowSchema(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberConstraints(narrowSchema(member, "number") ?? narrowSchema(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthConstraints(narrowSchema(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const transformed = this.transform(member);
+					if (transformed) base = `${base}.and(${transformed})`;
+				}
+				return base;
+			}
+		},
+		print(node) {
+			const { keysToOmit } = this.options;
+			let base = this.transform(node);
+			if (!base) return null;
+			const meta = 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/components/Zod.tsx
+function Zod({ name, node, coercion, guidType, wrapOutput, inferTypeName, resolver, keysToOmit }) {
+	const output = printerZod({
+		coercion,
+		guidType,
+		wrapOutput,
+		resolver,
+		schemaName: name,
+		keysToOmit
+	}).print(node);
+	if (!output) return;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Const, {
+			export: true,
+			name,
+			children: output
+		})
+	}), inferTypeName && /* @__PURE__ */ jsx(File.Source, {
+		name: inferTypeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			export: true,
+			name: inferTypeName,
+			children: `z.infer<typeof ${name}>`
+		})
+	})] });
+}
+//#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 = 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 ? 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 = 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(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(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(narrowSchema(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberChecksMini(narrowSchema(member, "number") ?? narrowSchema(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthChecksMini(narrowSchema(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const transformed = this.transform(member);
+					if (transformed) base = `z.intersection(${base}, ${transformed})`;
+				}
+				return base;
+			}
+		},
+		print(node) {
+			const { keysToOmit } = this.options;
+			let base = this.transform(node);
+			if (!base) return null;
+			const meta = 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/components/ZodMini.tsx
+function ZodMini({ name, node, guidType, wrapOutput, inferTypeName, resolver, keysToOmit }) {
+	const output = printerZodMini({
+		guidType,
+		wrapOutput,
+		resolver,
+		schemaName: name,
+		keysToOmit
+	}).print(node);
+	if (!output) return;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Const, {
+			export: true,
+			name,
+			children: output
+		})
+	}), inferTypeName && /* @__PURE__ */ jsx(File.Source, {
+		name: inferTypeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ 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 = new Set(["zod", "zod/mini"]);
+//#endregion
+//#region src/generators/zodGenerator.tsx
+const zodGenerator = defineGenerator({
+	name: "zod",
+	type: "react",
+	Schema({ node, adapter, options, config, resolver }) {
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		if (!transformedNode.name) return;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolver.default(schemaName, "function"),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const inferTypeName = inferred ? resolver.resolveInferName(resolver.resolveName(transformedNode.name)) : void 0;
+		const meta = {
+			name: resolver.default(transformedNode.name, "function"),
+			file: resolver.resolveFile({
+				name: transformedNode.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [transformedNode.name, imp.path].join("-"))),
+				mini ? /* @__PURE__ */ jsx(ZodMini, {
+					name: meta.name,
+					node: transformedNode,
+					guidType,
+					wrapOutput,
+					inferTypeName,
+					resolver
+				}) : /* @__PURE__ */ jsx(Zod, {
+					name: meta.name,
+					node: transformedNode,
+					coercion,
+					guidType,
+					wrapOutput,
+					inferTypeName,
+					resolver
+				})
+			]
+		});
+	},
+	Operation({ node, adapter, options, config, resolver }) {
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, transformers } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const params = caseParams(transformedNode.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: transformedNode.operationId,
+			extname: ".ts",
+			tag: transformedNode.tags[0] ?? "default",
+			path: transformedNode.path
+		}, {
+			root,
+			output,
+			group
+		}) };
+		function renderSchemaEntry({ schema, name, keysToOmit }) {
+			if (!schema) return null;
+			const inferTypeName = inferred ? resolver.resolveInferName(name) : void 0;
+			const imports = adapter.getImports(schema, (schemaName) => ({
+				name: resolver.default(schemaName, "function"),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name
+			}, [
+				name,
+				imp.path,
+				imp.name
+			].join("-"))), mini ? /* @__PURE__ */ jsx(ZodMini, {
+				name,
+				node: schema,
+				guidType,
+				wrapOutput,
+				inferTypeName,
+				resolver,
+				keysToOmit
+			}) : /* @__PURE__ */ jsx(Zod, {
+				name,
+				node: schema,
+				coercion,
+				guidType,
+				wrapOutput,
+				inferTypeName,
+				resolver,
+				keysToOmit
+			})] });
+		}
+		const paramSchemas = params.map((param) => renderSchemaEntry({
+			schema: param.schema,
+			name: resolver.resolveParamName(node, param)
+		}));
+		const responseSchemas = transformedNode.responses.map((res) => renderSchemaEntry({
+			schema: res.schema,
+			name: resolver.resolveResponseStatusName(transformedNode, res.statusCode),
+			keysToOmit: res.keysToOmit
+		}));
+		const requestSchema = transformedNode.requestBody?.schema ? renderSchemaEntry({
+			schema: {
+				...transformedNode.requestBody.schema,
+				description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description
+			},
+			name: resolver.resolveDataName(transformedNode),
+			keysToOmit: transformedNode.requestBody.keysToOmit
+		}) : null;
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				paramSchemas,
+				responseSchemas,
+				requestSchema
+			]
+		});
+	},
+	Operations({ nodes, adapter, options, config, resolver }) {
+		const { output, importPath, group, operations, paramsCasing, transformers } = options;
+		if (!operations) return;
+		const root = path.resolve(config.root, config.output.path);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const meta = { file: resolver.resolveFile({
+			name: "operations",
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group
+		}) };
+		const transformedOperations = nodes.map((node) => {
+			const transformedNode = transform(node, composeTransformers(...transformers));
+			return {
+				node: transformedNode,
+				data: buildSchemaNames(transformedNode, {
+					params: caseParams(transformedNode.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__ */ jsx(File.Import, {
+				name: [name],
+				root: meta.file.path,
+				path: opFile.path
+			}, [name, opFile.path].join("-")));
+		});
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports,
+				/* @__PURE__ */ jsx(Operations, {
+					name: "operations",
+					operations: transformedOperations
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/zodGeneratorLegacy.tsx
+function buildGroupedParamsSchema({ params, optional }) {
+	return createSchema({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => {
+			return 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 ? createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	}) : createSchema({
+		type: "union",
+		members: successResponses.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : createSchema({ type: "any" });
+	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
+	}) : createSchema({
+		type: "union",
+		members: errorResponses.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : createSchema({ type: "any" });
+	const properties = [createProperty({
+		name: "Response",
+		required: true,
+		schema: responseSchema
+	})];
+	if (!isGet && node.requestBody?.schema) properties.push(createProperty({
+		name: "Request",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveDataName(node)
+		})
+	}));
+	const queryParam = node.parameters.find((p) => p.in === "query");
+	if (queryParam) properties.push(createProperty({
+		name: "QueryParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveQueryParamsName(node, queryParam)
+		})
+	}));
+	const pathParam = node.parameters.find((p) => p.in === "path");
+	if (pathParam) properties.push(createProperty({
+		name: "PathParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolvePathParamsName(node, pathParam)
+		})
+	}));
+	const headerParam = node.parameters.find((p) => p.in === "header");
+	if (headerParam) properties.push(createProperty({
+		name: "HeaderParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveHeaderParamsName(node, headerParam)
+		})
+	}));
+	properties.push(createProperty({
+		name: "Errors",
+		required: true,
+		schema: errorsSchema
+	}));
+	return 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 createSchema({ type: "any" });
+	if (successResponses.length === 1) return createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	});
+	return createSchema({
+		type: "union",
+		members: successResponses.map((res) => 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 = defineGenerator({
+	name: "zod-legacy",
+	type: "react",
+	Schema({ node, adapter, options, config, resolver }) {
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, transformers = [] } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		if (!transformedNode.name) return;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolver.default(schemaName, "function"),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const inferTypeName = inferred ? resolver.resolveInferName(resolver.resolveName(transformedNode.name)) : void 0;
+		const meta = {
+			name: resolver.default(transformedNode.name, "function"),
+			file: resolver.resolveFile({
+				name: transformedNode.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [transformedNode.name, imp.path].join("-"))),
+				mini ? /* @__PURE__ */ jsx(ZodMini, {
+					name: meta.name,
+					node: transformedNode,
+					guidType,
+					wrapOutput,
+					inferTypeName,
+					resolver
+				}) : /* @__PURE__ */ jsx(Zod, {
+					name: meta.name,
+					node: transformedNode,
+					coercion,
+					guidType,
+					wrapOutput,
+					inferTypeName,
+					resolver
+				})
+			]
+		});
+	},
+	Operation({ node, adapter, options, config, resolver }) {
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, transformers } = options;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const params = caseParams(transformedNode.parameters, paramsCasing);
+		const meta = { file: resolver.resolveFile({
+			name: transformedNode.operationId,
+			extname: ".ts",
+			tag: transformedNode.tags[0] ?? "default",
+			path: transformedNode.path
+		}, {
+			root,
+			output,
+			group
+		}) };
+		function renderSchemaEntry({ schema, name, keysToOmit }) {
+			if (!schema) return null;
+			const inferTypeName = inferred ? resolver.resolveInferName(name) : void 0;
+			const imports = adapter.getImports(schema, (schemaName) => ({
+				name: resolver.default(schemaName, "function"),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: meta.file.path,
+				path: imp.path,
+				name: imp.name
+			}, [
+				name,
+				imp.path,
+				imp.name
+			].join("-"))), mini ? /* @__PURE__ */ jsx(ZodMini, {
+				name,
+				node: schema,
+				guidType,
+				wrapOutput,
+				inferTypeName,
+				resolver,
+				keysToOmit
+			}) : /* @__PURE__ */ jsx(Zod, {
+				name,
+				node: schema,
+				coercion,
+				guidType,
+				wrapOutput,
+				inferTypeName,
+				resolver,
+				keysToOmit
+			})] });
+		}
+		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 = transformedNode.responses.map((res) => {
+			const responseName = resolver.resolveResponseStatusName(transformedNode, res.statusCode);
+			return renderSchemaEntry({
+				schema: {
+					...res.schema,
+					description: res.description ?? res.schema.description
+				},
+				name: responseName,
+				keysToOmit: res.keysToOmit
+			});
+		});
+		const requestSchema = transformedNode.requestBody?.schema ? renderSchemaEntry({
+			schema: {
+				...transformedNode.requestBody.schema,
+				description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description
+			},
+			name: resolver.resolveDataName(transformedNode),
+			keysToOmit: transformedNode.requestBody.keysToOmit
+		}) : null;
+		const legacyParamTypes = [
+			pathParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: pathParams,
+					optional: pathParams.every((p) => !p.required)
+				}),
+				name: resolver.resolvePathParamsName(transformedNode, pathParams[0])
+			}) : null,
+			queryParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: queryParams,
+					optional: queryParams.every((p) => !p.required)
+				}),
+				name: resolver.resolveQueryParamsName(transformedNode, queryParams[0])
+			}) : null,
+			headerParams.length > 0 ? renderSchemaEntry({
+				schema: buildGroupedParamsSchema({
+					params: headerParams,
+					optional: headerParams.every((p) => !p.required)
+				}),
+				name: resolver.resolveHeaderParamsName(transformedNode, headerParams[0])
+			}) : null
+		];
+		const legacyResponsesSchema = renderSchemaEntry({
+			schema: buildLegacyResponsesSchemaNode(transformedNode, { resolver }),
+			name: resolver.resolveResponsesName(transformedNode)
+		});
+		const legacyResponseSchema = renderSchemaEntry({
+			schema: buildLegacyResponseUnionSchemaNode(transformedNode, { resolver }),
+			name: resolver.resolveResponseName(transformedNode)
+		});
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				legacyParamTypes,
+				responseSchemas,
+				requestSchema,
+				legacyResponseSchema,
+				legacyResponsesSchema
+			]
+		});
+	},
+	Operations({ nodes, adapter, options, config, resolver }) {
+		const { output, importPath, group, operations, paramsCasing, transformers } = options;
+		if (!operations) return;
+		const root = path.resolve(config.root, config.output.path);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const meta = { file: resolver.resolveFile({
+			name: "operations",
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group
+		}) };
+		const transformedOperations = nodes.map((node) => {
+			const transformedNode = transform(node, composeTransformers(...transformers));
+			return {
+				node: transformedNode,
+				data: buildLegacySchemaNames(transformedNode, caseParams(transformedNode.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__ */ jsx(File.Import, {
+				name: [name],
+				root: meta.file.path,
+				path: opFile.path
+			}, [name, opFile.path].join("-")));
+		});
+		return /* @__PURE__ */ jsxs(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__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports,
+				/* @__PURE__ */ jsx(Operations, {
+					name: "operations",
+					operations: transformedOperations
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverZod.ts
+function toSchemaName(name, type) {
+	const resolved = camelCase(name, {
+		suffix: type ? "schema" : void 0,
+		isFile: type === "file"
+	});
+	if (type === "type") return pascalCase(resolved);
+	return resolved;
+}
+/**
+* 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 = defineResolver(() => {
+	return {
+		name: "default",
+		pluginName: "plugin-zod",
+		default(name, type) {
+			return toSchemaName(name, type);
+		},
+		resolveName(name) {
+			return this.default(name, "function");
+		},
+		resolveInferName(name) {
+			return pascalCase(name);
+		},
+		resolvePathName(name, type) {
+			return this.default(name, type);
+		},
+		resolveParamName(node, param) {
+			return this.resolveName(`${node.operationId} ${param.in} ${param.name}`);
+		},
+		resolveResponseStatusName(node, statusCode) {
+			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveDataName(node) {
+			return this.resolveName(`${node.operationId} Data`);
+		},
+		resolveResponsesName(node) {
+			return this.resolveName(`${node.operationId} Responses`);
+		},
+		resolveResponseName(node) {
+			return this.resolveName(`${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 = defineResolver(() => {
+	return {
+		...resolverZod,
+		pluginName: "plugin-zod",
+		resolveResponseStatusName(node, statusCode) {
+			if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
+			return this.resolveName(`${node.operationId} ${statusCode}`);
+		},
+		resolveDataName(node) {
+			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponsesName(node) {
+			const suffix = node.method === "GET" ? "Query" : "Mutation";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponseName(node) {
+			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolvePathParamsName(node, _param) {
+			return this.resolveName(`${node.operationId} PathParams`);
+		},
+		resolveQueryParamsName(node, _param) {
+			return this.resolveName(`${node.operationId} QueryParams`);
+		},
+		resolveHeaderParamsName(node, _param) {
+			return this.resolveName(`${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).
+*/
+const presets = definePresets({
+	default: {
+		name: "default",
+		resolvers: [resolverZod],
+		generators: [zodGenerator]
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolvers: [resolverZodLegacy],
+		generators: [zodGeneratorLegacy]
+	}
+});
+//#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";
+/**
+* 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 = 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" : satisfiesDependency("zod", ">=4") ? "4" : "3", guidType = "uuid", importPath = mini ? "zod/mini" : version === "4" ? "zod/v4" : "zod", coercion = false, inferred = false, generators = [zodGenerator, operations ? 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, compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
+	const preset = getPreset({
+		preset: compatibilityPreset,
+		presets,
+		resolvers: userResolvers,
+		transformers: userTransformers,
+		generators: userGenerators
+	});
+	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: {}
-		},
-		pre: [pluginOasName, typed ? pluginTsName : void 0].filter(Boolean),
+		get resolver() {
+			return preset.resolver;
+		},
+		get options() {
+			return {
+				output,
+				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,
+				transformers: preset.transformers
+			};
+		},
 		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.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 path.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 path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			if (!resolvePathWarning) {
+				this.events.emit("warn", "Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead");
+				resolvePathWarning = true;
 			}
-			return path.resolve(root, output.path, baseName);
+			return this.plugin.resolver.resolvePath({
+				baseName,
+				pathMode,
+				tag: options?.group?.tag,
+				path: options?.group?.path
+			}, {
+				root: path.resolve(this.config.root, this.config.output.path),
+				output,
+				group: this.plugin.options.group
+			});
 		},
 		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;
+			if (!resolveNameWarning) {
+				this.events.emit("warn", "Do not use resolveName for pluginZod, use resolverZod.default instead");
+				resolveNameWarning = true;
+			}
+			return this.plugin.resolver.default(name, type);
 		},
 		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.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: path.resolve(root, ".kubb/ToZod.ts"),
-				sources: [{
-					name: "ToZod",
-					value: source
-				}],
-				imports: [],
-				exports: []
-			});
-			const schemaFiles = await new 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 OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this;
+			const root = path.resolve(config.root, config.output.path);
+			if (!adapter) throw new Error(`[${pluginZodName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
+			await openInStudio({ ast: true });
+			const collectedOperations = [];
+			const generatorContext = {
+				generators: preset.generators,
+				plugin,
+				resolver,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...operationFiles);
+				fabric,
+				adapter,
+				config,
+				driver
+			};
+			await walk(rootNode, {
+				depth: "shallow",
+				async schema(schemaNode) {
+					await runGeneratorSchema(schemaNode, generatorContext);
+				},
+				async operation(operationNode) {
+					if (resolver.resolveOptions(operationNode, {
+						options: plugin.options,
+						exclude,
+						include,
+						override
+					}) !== null) collectedOperations.push(operationNode);
+					await runGeneratorOperation(operationNode, generatorContext);
+				}
+			});
+			await runGeneratorOperations(collectedOperations, generatorContext);
 			const barrelFiles = await getBarrelFiles(this.fabric.files, {
 				type: output.barrelType ?? "named",
 				root,
@@ -173,6 +1731,6 @@ const pluginZod = createPlugin((options) => {
 	};
 });
 //#endregion
-export { pluginZod, pluginZodName };
+export { pluginZod, pluginZodName, printerZod, printerZodMini, resolverZod, resolverZodLegacy, zodGenerator, zodGeneratorLegacy };
 
 //# sourceMappingURL=index.js.map