@kubb/plugin-zod 5.0.0-beta.42 → 5.0.0-beta.64

package/dist/index.js

@@ -1,6 +1,7 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { Const, File, Type, jsxRendererSync } from "@kubb/renderer-jsx";
+import { buildList, buildObject, caseParams, containsCircularRef, extractRefName, lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, objectKey, stringify, stringifyObject, syncSchemaRef, toRegExpString } from "@kubb/ast/utils";
+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
 /**
@@ -13,117 +14,57 @@ import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* 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(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
 * Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @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.
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
 *
-* @example
-* 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 Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
 *
-* @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 PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
 *
-* @example
-* toRegExpString('^(?im)foo')       // → 'new RegExp("foo", "im")'
-* toRegExpString('^(?im)foo', null) // → '/foo/im'
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-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)}` : ""})`;
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -305,26 +246,24 @@ function resolveContentTypeVariants(entries, baseName) {
 * shared default naming so every plugin groups output consistently:
 *
 * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
 *
 * A user-provided `group.name` always wins over the default namer, so callers stay in
 * control of their output folders. Returns `null` when grouping is disabled, matching the
 * per-plugin convention.
 *
 * @param group - The user-supplied group option, or `undefined` to disable grouping.
-* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
 *
 * @example
 * ```ts
-* createGroupConfig(group, { suffix: 'Controller' }) // plugin-ts, plugin-client, …
-* createGroupConfig(group, { suffix: 'Requests' })   // plugin-cypress, plugin-mcp
+* createGroupConfig(group) // shared across every plugin
 * ```
 */
-function createGroupConfig(group, options) {
+function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return `${camelCase(ctx.group)}${options.suffix}`;
+		return camelCase(ctx.group);
 	};
 	return {
 		...group,
@@ -487,12 +426,12 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	if (hasCodec(node)) return true;
 	if (node.type === "ref") {
 		if (!node.ref) return false;
-		const refName = ast.extractRefName(node.ref);
+		const refName = extractRefName(node.ref);
 		if (refName) {
 			if (seen.has(refName)) return false;
 			seen.add(refName);
 		}
-		const resolved = ast.syncSchemaRef(node);
+		const resolved = syncSchemaRef(node);
 		if (resolved.type === "ref") return false;
 		return containsCodec(resolved, seen);
 	}
@@ -504,6 +443,13 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	return children.some((child) => containsCodec(child, seen));
 }
 /**
+* Collects the names of `$ref` schemas that transitively contain a codec, so the generator can route
+* them to their input (encode) variant.
+*/
+function collectCodecRefNames(node) {
+	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? extractRefName(n.ref) ?? void 0 : void 0 });
+}
+/**
 * Collects all resolved schema names for an operation's parameters and responses
 * into a single lookup object, useful for building imports and type references.
 */
@@ -628,7 +574,7 @@ 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);
+		const schema = syncSchemaRef(node);
 		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
 	return member;
@@ -713,24 +659,24 @@ const printerZod = ast.definePrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
 				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
 				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.resolveInputSchemaName(refName) ?? refName : this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
 			object(node) {
-				const objectBase = `z.object({\n    ${node.properties.map((prop) => {
-					const { name: propName, schema } = prop;
-					const meta = ast.syncSchemaRef(schema);
-					const isNullable = meta.nullable;
-					const isOptional = schema.optional;
-					const isNullish = schema.nullish;
-					const hasSelfRef = this.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+				const objectBase = `z.object(${buildObject(mapSchemaProperties(node, (schema) => {
+					const hasSelfRef = isCyclic(schema);
 					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
+					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
 					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
+					return baseOutput;
+				}).map(({ name: propName, property, output: baseOutput }) => {
+					const { schema } = property;
+					const meta = syncSchemaRef(schema);
 					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
 						output: baseOutput,
 						schema
@@ -738,42 +684,41 @@ const printerZod = ast.definePrinter((options) => {
 					const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 					const value = applyModifiers({
 						value: wrappedOutput,
-						nullable: isNullable,
-						optional: isOptional,
-						nullish: isNullish,
+						nullable: meta.nullable,
+						optional: schema.optional || property.required === false,
+						nullish: schema.nullish,
 						defaultValue: meta.default,
 						description: descriptionToApply
 					});
-					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
-					return `"${propName}": ${value}`;
-				}).join(",\n    ")}\n    })`;
+					return isCyclic(schema) ? lazyGetter({
+						name: propName,
+						body: value
+					}) : `${objectKey(propName)}: ${value}`;
+				}))})`;
 				return (() => {
 					if (node.additionalProperties && node.additionalProperties !== true) {
 						const catchallType = this.transform(node.additionalProperties);
 						return catchallType ? `${objectBase}.catchall(${catchallType})` : objectBase;
 					}
-					if (node.additionalProperties === true) return `${objectBase}.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
+					if (node.additionalProperties === true) return `${objectBase}.catchall(${this.transform(ast.factory.createSchema({ type: "unknown" }))})`;
 					if (node.additionalProperties === false) return `${objectBase}.strict()`;
 					return objectBase;
 				})();
 			},
 			array(node) {
-				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			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);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema) : output).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(", ")}])`;
+				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -795,7 +740,7 @@ const printerZod = ast.definePrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -892,54 +837,53 @@ const printerZodMini = ast.definePrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
+				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.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 });
+				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
+				return `z.object(${buildObject(mapSchemaProperties(node, (schema) => {
+					const hasSelfRef = isCyclic(schema);
 					const savedCyclicSchemas = this.options.cyclicSchemas;
 					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
+					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
 					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
+					return baseOutput;
+				}).map(({ name: propName, property, output: baseOutput }) => {
+					const { schema } = property;
+					const meta = syncSchemaRef(schema);
 					const value = applyMiniModifiers({
 						value: this.options.wrapOutput ? this.options.wrapOutput({
 							output: baseOutput,
 							schema
 						}) || baseOutput : baseOutput,
-						nullable: isNullable,
-						optional: isOptional,
-						nullish: isNullish,
+						nullable: meta.nullable,
+						optional: schema.optional || property.required === false,
+						nullish: schema.nullish,
 						defaultValue: meta.default
 					});
-					if (hasSelfRef) return `get "${propName}"() { return ${value} }`;
-					return `"${propName}": ${value}`;
-				}).join(",\n    ")}\n    })`;
+					return isCyclic(schema) ? lazyGetter({
+						name: propName,
+						body: value
+					}) : `${objectKey(propName)}: ${value}`;
+				}))})`;
 			},
 			array(node) {
-				const base = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
+				const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple([${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ")}])`;
+				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			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);
+				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
-				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, [${members.join(", ")}])`;
-				return `z.union([${members.join(", ")}])`;
+				if (node.discriminatorPropertyName && !nodeMembers.some((m) => m.type === "intersection")) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -961,7 +905,7 @@ const printerZodMini = ast.definePrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyMiniModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1037,17 +981,16 @@ function getMiniPrinter(resolver, params) {
 */
 const zodGenerator = defineGenerator({
 	name: "zod",
-	renderer: jsxRendererSync,
+	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 cyclicSchemas = new Set(ctx.meta.circularNames);
 		const hasCodec = !mini && containsCodec(node);
-		const codecRefNames = new Set(hasCodec ? ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 }) : []);
+		const codecRefNames = new Set(hasCodec ? collectCodecRefNames(node) : []);
 		const importEntries = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveSchemaName(schemaName),
 			path: resolver.resolveFile({
@@ -1060,7 +1003,7 @@ const zodGenerator = defineGenerator({
 			}).path
 		}));
 		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
-			name: resolver.resolveInputSchemaName(schemaName),
+			name: [resolver.resolveInputSchemaName(schemaName)],
 			path: resolver.resolveFile({
 				name: schemaName,
 				extname: ".ts"
@@ -1129,7 +1072,7 @@ const zodGenerator = defineGenerator({
 					path: importPath,
 					isNameSpace: isZodImport
 				}),
-				mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
@@ -1158,9 +1101,8 @@ const zodGenerator = defineGenerator({
 		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 params = caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1175,7 +1117,7 @@ const zodGenerator = defineGenerator({
 		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
 			if (!schema) return null;
 			const inferTypeName = inferred ? resolver.resolveTypeName(name) : null;
-			const codecRefNames = direction === "input" && !mini ? new Set(ast.collect(schema, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 })) : null;
+			const codecRefNames = direction === "input" && !mini ? new Set(collectCodecRefNames(schema)) : null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
 				name: codecRefNames?.has(schemaName) ? resolver.resolveInputSchemaName(schemaName) : resolver.resolveSchemaName(schemaName),
 				path: resolver.resolveFile({
@@ -1217,7 +1159,7 @@ const zodGenerator = defineGenerator({
 				cyclicSchemas,
 				nodes: printer?.nodes
 			})[direction];
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name
@@ -1234,9 +1176,9 @@ const zodGenerator = defineGenerator({
 		}
 		function buildContentTypeVariants(entries, baseName, decorate, direction) {
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = ast.createSchema({
+			const unionSchema = ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => ast.createSchema({
+				members: variants.map((variant) => ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
@@ -1274,12 +1216,12 @@ const zodGenerator = defineGenerator({
 				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({
+			const members = responsesWithSchema.map((res) => ast.factory.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
 			}));
 			return renderSchemaEntry({
-				schema: members.length === 1 ? members[0] : ast.createSchema({
+				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
 					type: "union",
 					members
 				}),
@@ -1357,7 +1299,7 @@ const zodGenerator = defineGenerator({
 			return {
 				node,
 				data: buildSchemaNames(node, {
-					params: ast.caseParams(node.parameters, paramsCasing),
+					params: caseParams(node.parameters, paramsCasing),
 					resolver
 				})
 			};
@@ -1425,14 +1367,16 @@ const zodGenerator = defineGenerator({
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
 * paths for every generated Zod schema. Schemas use camelCase with a
-* `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase.
+* `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase
+* with a `SchemaType` suffix (`PetSchemaType`), so the value and the type
+* never share an identifier even when the schema name is all-uppercase.
 *
 * @example Resolve schema and type names
 * ```ts
 * import { resolverZod } from '@kubb/plugin-zod'
 *
 * resolverZod.default('list pets', 'function') // 'listPetsSchema'
-* resolverZod.resolveSchemaTypeName('pet')     // 'PetSchema'
+* resolverZod.resolveSchemaTypeName('pet')     // 'PetSchemaType'
 * ```
 */
 const resolverZod = defineResolver(() => {
@@ -1440,17 +1384,14 @@ const resolverZod = defineResolver(() => {
 		name: "default",
 		pluginName: "plugin-zod",
 		default(name, type) {
-			const resolved = camelCase(name, {
-				isFile: type === "file",
-				suffix: type ? "schema" : void 0
-			});
-			return type === "file" ? resolved : ensureValidVarName(resolved);
+			if (type === "file") return toFilePath(name, (part) => camelCase(part, { suffix: "schema" }));
+			return ensureValidVarName(camelCase(name, { suffix: type ? "schema" : void 0 }));
 		},
 		resolveSchemaName(name) {
 			return ensureValidVarName(camelCase(name, { suffix: "schema" }));
 		},
 		resolveSchemaTypeName(name) {
-			return ensureValidVarName(pascalCase(name, { suffix: "schema" }));
+			return ensureValidVarName(pascalCase(name, { suffix: "schema type" }));
 		},
 		resolveInputSchemaName(name) {
 			return this.resolveSchemaName(`${name} input`);
@@ -1459,7 +1400,7 @@ const resolverZod = defineResolver(() => {
 			return this.resolveSchemaTypeName(`${name} input`);
 		},
 		resolveTypeName(name) {
-			return ensureValidVarName(pascalCase(name));
+			return ensureValidVarName(pascalCase(name, { suffix: "type" }));
 		},
 		resolvePathName(name, type) {
 			return this.default(name, type);
@@ -1525,9 +1466,9 @@ const pluginZodName = "plugin-zod";
 const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginZodName,
 		options,
@@ -1553,7 +1494,7 @@ const pluginZod = definePlugin((options) => {
 				...resolverZod,
 				...userResolver
 			} : resolverZod);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(zodGenerator);
 			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }