@kubb/plugin-zod 5.0.0-alpha.8 → 5.0.0-beta.10

package/dist/index.js

@@ -1,10 +1,7 @@
-import "./chunk--u3MIqq1.js";
-import { n as operationsGenerator, t as zodGenerator } from "./generators-lTWPS6oN.js";
-import { source } from "./templates/ToZod.source.js";
-import path from "node:path";
-import { PackageManager, createPlugin, getBarrelFiles, getMode } from "@kubb/core";
-import { OperationGenerator, SchemaGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { Const, File, Type, jsxRenderer } from "@kubb/renderer-jsx";
+import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -24,9 +21,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("/");
 }
 /**
@@ -60,116 +60,1085 @@ 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/components/Zod.tsx
+function Zod({ name, node, printer, inferTypeName }) {
+	const output = printer.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/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?.content?.[0]?.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;
+}
+//#endregion
+//#region src/printers/printerZod.ts
+function strictOneOfMember$1(member, node) {
+	if (node.type === "object" && node.additionalProperties === void 0) return `${member}.strict()`;
+	if (node.type === "ref") {
+		if (member.startsWith("z.lazy(")) return member;
+		const schema = ast.syncSchemaRef(node);
+		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+	}
+	return member;
+}
+__name(strictOneOfMember$1, "strictOneOfMember");
+/**
+* Zod v4 printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a Zod v4 code string using the chainable API
+* (`.optional()`, `.nullable()`, `.omit()`, etc.). For improved tree-shaking, see {@link printerZodMini}.
+*
+* @example Chainable API
+* ```ts
+* const printer = printerZod({ coercion: false })
+* const code = printer.print(stringNode) // "z.string()"
+* ```
+*/
+const printerZod = ast.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) {
+				const offset = node.offset || this.options.dateType === "stringOffset";
+				const local = node.local || this.options.dateType === "stringLocal";
+				if (offset) return "z.iso.datetime({ offset: true })";
+				if (local) return "z.iso.datetime({ local: true })";
+				return "z.iso.datetime()";
+			},
+			time(node) {
+				if (node.representation === "string") return "z.iso.time()";
+				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+			},
+			uuid(node) {
+				return `${this.options.guidType === "guid" ? "z.guid()" : "z.uuid()"}${lengthConstraints(node)}`;
+			},
+			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 ? ast.extractRefName(node.ref) ?? node.name : node.name;
+				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				let result = `z.object({\n    ${node.properties.map((prop) => {
+					const { name: propName, schema } = prop;
+					const meta = ast.syncSchemaRef(schema);
+					const isNullable = meta.nullable;
+					const isOptional = schema.optional;
+					const isNullish = schema.nullish;
+					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					if (hasSelfRef) this.options.cyclicSchemas = void 0;
+					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
+					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
+						output: baseOutput,
+						schema
+					}) || baseOutput : baseOutput;
+					let descriptionToApply = meta.description;
+					if (schema.type !== "ref" && meta.type === "ref") descriptionToApply = void 0;
+					const value = applyModifiers({
+						value: wrappedOutput,
+						nullable: isNullable,
+						optional: isOptional,
+						nullish: isNullish,
+						defaultValue: meta.default,
+						description: descriptionToApply
+					});
+					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
+					return `"${propName}": ${value}`;
+				}).join(",\n    ")}\n    })`;
+				if (node.additionalProperties && node.additionalProperties !== true) {
+					const catchallType = this.transform(node.additionalProperties);
+					if (catchallType) result += `.catchall(${catchallType})`;
+				} else if (node.additionalProperties === true) result += `.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
+				else if (node.additionalProperties === false) result += ".strict()";
+				return result;
+			},
+			array(node) {
+				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
+				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
+				return result;
+			},
+			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((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember$1(member, memberNode) : member;
+				}).filter(Boolean);
+				if (members.length === 0) return "";
+				if (members.length === 1) return members[0];
+				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
+				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(ast.narrowSchema(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthConstraints(ast.narrowSchema(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const 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 = ast.syncSchemaRef(node);
+			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
+				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+			}
+			return applyModifiers({
+				value: base,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default,
+				description: meta.description
+			});
+		}
+	};
+});
+//#endregion
+//#region src/printers/printerZodMini.ts
+function strictOneOfMember(member, node) {
+	if (node.type === "object" && (node.additionalProperties === void 0 || node.additionalProperties === false)) return member.replace(/^z\.object\(/, "z.strictObject(");
+	return member;
+}
+/**
+* Zod v4 **Mini** printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST into a Zod v4 code string using the functional API
+* (`z.optional(z.string())`) for improved tree-shaking. See {@link printerZod} for the chainable API.
+*
+* @example Functional Mini API
+* ```ts
+* const printer = printerZodMini({})
+* const code = printer.print(optionalStringNode) // "z.optional(z.string())"
+* ```
+*/
+const printerZodMini = ast.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 ? ast.extractRefName(node.ref) ?? node.name : node.name;
+				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
+				return resolvedName;
+			},
+			object(node) {
+				return `z.object({\n    ${node.properties.map((prop) => {
+					const { name: propName, schema } = prop;
+					const meta = ast.syncSchemaRef(schema);
+					const isNullable = meta.nullable;
+					const isOptional = schema.optional;
+					const isNullish = schema.nullish;
+					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+					if (hasSelfRef) this.options.cyclicSchemas = void 0;
+					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
+					if (hasSelfRef) this.options.cyclicSchemas = options.cyclicSchemas;
+					const value = applyMiniModifiers({
+						value: this.options.wrapOutput ? this.options.wrapOutput({
+							output: baseOutput,
+							schema
+						}) || baseOutput : baseOutput,
+						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(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((memberNode) => {
+					const member = this.transform(memberNode);
+					return member && node.strategy === "one" ? strictOneOfMember(member, memberNode) : member;
+				}).filter(Boolean);
+				if (members.length === 0) return "";
+				if (members.length === 1) return members[0];
+				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
+				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(ast.narrowSchema(member, "string") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "number" || member.primitive === "integer") {
+						const c = numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					} else if (member.primitive === "array") {
+						const c = lengthChecksMini(ast.narrowSchema(member, "array") ?? {});
+						if (c) {
+							base += c;
+							continue;
+						}
+					}
+					const 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 = ast.syncSchemaRef(node);
+			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) {
+				const lazyMatch = base.match(/^z\.lazy\(\(\)\s*=>\s*(.+)\)$/);
+				if (lazyMatch) base = `z.lazy(() => ${lazyMatch[1]}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} }))`;
+				else base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
+			}
+			return applyMiniModifiers({
+				value: base,
+				nullable: meta.nullable,
+				optional: meta.optional,
+				nullish: meta.nullish,
+				defaultValue: meta.default
+			});
+		}
+	};
+});
+//#endregion
+//#region src/generators/zodGenerator.tsx
+const zodGenerator = defineGenerator({
+	name: "zod",
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
+		const dateType = adapter.options.dateType;
+		if (!node.name) return;
+		const mode = ctx.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 cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
+		const schemaPrinter = mini ? printerZodMini({
+			guidType,
+			wrapOutput,
+			resolver,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		}) : printerZod({
+			coercion,
+			guidType,
+			dateType,
+			wrapOutput,
+			resolver,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		});
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.inputNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.inputNode, {
+				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
+				}, [node.name, imp.path].join("-"))),
+				/* @__PURE__ */ jsx(Zod, {
+					name: meta.name,
+					node,
+					printer: schemaPrinter,
+					inferTypeName
+				})
+			]
+		});
+	},
+	operation(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
+		const dateType = adapter.options.dateType;
+		const mode = ctx.getMode(output);
+		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
+		const params = 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
+		}) };
+		const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
+		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,
+				keysToOmit,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			}) : printerZod({
+				coercion,
+				guidType,
+				dateType,
+				wrapOutput,
+				resolver,
+				keysToOmit,
+				cyclicSchemas,
+				nodes: printer?.nodes
+			});
+			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("-"))), /* @__PURE__ */ 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 responsesWithSchema = node.responses.filter((res) => res.schema);
+		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
+			const responseUnionName = resolver.resolveResponseName(node);
+			if (new Set(responsesWithSchema.flatMap((res) => res.schema ? adapter.getImports(res.schema, (schemaName) => ({
+				name: resolver.resolveSchemaName(schemaName),
+				path: ""
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseUnionName)) return null;
+			const members = responsesWithSchema.map((res) => ast.createSchema({
+				type: "ref",
+				name: resolver.resolveResponseStatusName(node, res.statusCode)
+			}));
+			return renderSchemaEntry({
+				schema: members.length === 1 ? members[0] : ast.createSchema({
+					type: "union",
+					members
+				}),
+				name: responseUnionName
+			});
+		})() : null;
+		const requestSchema = node.requestBody?.content?.[0]?.schema ? renderSchemaEntry({
+			schema: {
+				...node.requestBody.content[0].schema,
+				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
+			},
+			name: resolver.resolveDataName(node),
+			keysToOmit: node.requestBody.content[0].keysToOmit
+		}) : null;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.inputNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.inputNode, {
+				output,
+				config
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				paramSchemas,
+				responseSchemas,
+				responseUnionSchema,
+				requestSchema
+			]
+		});
+	},
+	operations(nodes, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, importPath, group, operations, paramsCasing } = ctx.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: 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__ */ 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.inputNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.inputNode, {
+				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
+/**
+* Naming convention resolver for Zod plugin.
+*
+* Provides default naming helpers using camelCase with a `Schema` suffix for schemas.
+*
+* @example
+* `resolverZod.default('list pets', 'function')  // → 'listPetsSchema'`
+*/
+const resolverZod = 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/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+*/
 const pluginZodName = "plugin-zod";
-const pluginZod = createPlugin((options) => {
+/**
+* Generates Zod validation schemas from an OpenAPI specification.
+* Walks schemas and operations, delegates to generators, and writes barrel files
+* based on the configured `barrelType`.
+*
+* @example Zod schema generator
+* ```ts
+* import pluginZod from '@kubb/plugin-zod'
+* export default defineConfig({
+*   plugins: [pluginZod({ output: { path: 'zod' } })]
+* })
+* ```
+*/
+const pluginZod = definePlugin((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 PackageManager().isValidSync("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 = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+	const groupConfig = group ? {
+		...group,
+		name: (ctx) => {
+			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+			return `${camelCase(ctx.group)}Controller`;
+		}
+	} : void 0;
 	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),
-		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);
-			}
-			return path.resolve(root, output.path, baseName);
-		},
-		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 = 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,
+		options,
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions({
+				output,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...operationFiles);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
+				group: groupConfig,
+				typed,
+				importPath,
+				coercion,
+				operations,
+				inferred,
+				guidType,
+				mini,
+				wrapOutput,
+				paramsCasing,
+				printer
 			});
-			await this.upsertFile(...barrelFiles);
-		}
+			ctx.setResolver(userResolver ? {
+				...resolverZod,
+				...userResolver
+			} : resolverZod);
+			if (userTransformer) ctx.setTransformer(userTransformer);
+			ctx.addGenerator(zodGenerator);
+			for (const gen of userGenerators) ctx.addGenerator(gen);
+		} }
 	};
 });
 //#endregion
-export { pluginZod, pluginZodName };
+export { pluginZod as default, pluginZod, pluginZodName, printerZod, printerZodMini, resolverZod, zodGenerator };
 
 //# sourceMappingURL=index.js.map