@kubb/plugin-zod 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import { Const, File, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
@@ -41,31 +41,6 @@ function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -166,7 +141,7 @@ const reservedWords = /* @__PURE__ */ new Set([
 */
 function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+	return isIdentifier(name);
 }
 /**
 * Returns `name` when it's a syntactically valid JavaScript variable name,
@@ -188,6 +163,188 @@ function ensureValidVarName(name) {
 	if (!name || isValidVarName(name)) return name;
 	return `_${name}`;
 }
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/strings.ts
+/**
+* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
+* any backslash or single quote in the content.
+*
+* @example
+* ```ts
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
+* ```
+*/
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* ```ts
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
+* ```
+*/
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
+}
+/**
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+*
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
+*
+* @example
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+//#endregion
+//#region ../../internals/utils/src/codegen.ts
+const INDENT = "  ";
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
+*
+* @example
+* ```ts
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
+}
+/**
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
+*
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+/**
+* Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on
+* one line when no item spans multiple lines, and otherwise puts each item on its own line, indented
+* one level with a trailing comma and the closing bracket at column zero. Used for member lists such
+* as `z.union([…])` and `z.array([…])`.
+*
+* @example
+* ```ts
+* buildList(['z.string()', 'z.number()'])
+* // '[z.string(), z.number()]'
+* ```
+*/
+function buildList(items, brackets = ["[", "]"]) {
+	const [open, close] = brackets;
+	if (items.length === 0) return `${open}${close}`;
+	if (!items.some((item) => item.includes("\n"))) return `${open}${items.join(", ")}${close}`;
+	return `${open}\n${items.map((item) => `${indentLines(item)},`).join("\n")}\n${close}`;
+}
+/**
+* Emits a lazy getter for a circular-ref property position, `get name() { return body }`. The key
+* is quoted only when it is not a valid identifier. Used by the string printers to defer evaluation
+* of a recursive schema until first access.
+*
+* @example
+* ```ts
+* lazyGetter({ name: 'parent', body: 'z.lazy(() => Pet)' })
+* // "get parent() { return z.lazy(() => Pet) }"
+* ```
+*/
+function lazyGetter({ name, body }) {
+	return `get ${objectKey(name)}() { return ${body} }`;
+}
+//#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
 //#endregion
 //#region ../../internals/shared/src/params.ts
 const caseParamsCache = /* @__PURE__ */ new WeakMap();
@@ -453,7 +610,7 @@ function isObjectComposableIntersection(node, cyclicSchemas) {
 * Objects become `{}`, primitives become their string representation, strings are quoted.
 */
 function formatDefault(value) {
-	if (typeof value === "string") return ast.stringify(value);
+	if (typeof value === "string") return stringify(value);
 	if (typeof value === "object" && value !== null) return "{}";
 	return String(value ?? "");
 }
@@ -489,7 +646,7 @@ function defaultLiteral(node, value) {
 * Strings are quoted; numbers and booleans are emitted raw.
 */
 function formatLiteral(v) {
-	if (typeof v === "string") return ast.stringify(v);
+	if (typeof v === "string") return stringify(v);
 	return String(v);
 }
 /**
@@ -531,8 +688,7 @@ function patternKeySchemaMini({ patterns, regexType }) {
 	})}))`;
 }
 function patternKeySource({ patterns, regexType }) {
-	const source = patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|");
-	return ast.toRegExpString(source, regexFunc(regexType));
+	return toRegExpString(patterns.length === 1 ? patterns[0] : patterns.map((pattern) => `(${pattern})`).join("|"), regexFunc(regexType));
 }
 /**
 * Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
@@ -555,7 +711,7 @@ function lengthConstraints({ min, max, pattern, regexType }) {
 	return [
 		min !== void 0 ? `.min(${min})` : "",
 		max !== void 0 ? `.max(${max})` : "",
-		pattern !== void 0 ? `.regex(${ast.toRegExpString(pattern, regexFunc(regexType))})` : ""
+		pattern !== void 0 ? `.regex(${toRegExpString(pattern, regexFunc(regexType))})` : ""
 	].join("");
 }
 /**
@@ -577,7 +733,7 @@ function lengthChecksMini({ min, max, pattern, regexType }) {
 	const checks = [];
 	if (min !== void 0) checks.push(`z.minLength(${min})`);
 	if (max !== void 0) checks.push(`z.maxLength(${max})`);
-	if (pattern !== void 0) checks.push(`z.regex(${ast.toRegExpString(pattern, regexFunc(regexType))})`);
+	if (pattern !== void 0) checks.push(`z.regex(${toRegExpString(pattern, regexFunc(regexType))})`);
 	return checks.length ? `.check(${checks.join(", ")})` : "";
 }
 /**
@@ -593,7 +749,7 @@ function applyModifiers({ value, schema, nullable, optional, nullish, defaultVal
 	})();
 	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
 	const withDefault = literal !== null ? `${withModifier}.default(${literal})` : withModifier;
-	const withDescription = description ? `${withDefault}.describe(${ast.stringify(description)})` : withDefault;
+	const withDescription = description ? `${withDefault}.describe(${stringify(description)})` : withDefault;
 	return examples?.length ? `${withDescription}.meta({ examples: [${examples.map(formatDefault).join(", ")}] })` : withDescription;
 }
 function modifierDepth(schema) {
@@ -664,7 +820,7 @@ function buildZodObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
 	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	const entries = ast.mapSchemaProperties(objectNode, (schema) => {
+	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -685,12 +841,11 @@ function buildZodObjectShape(ctx, node) {
 			description: descriptionToApply,
 			examples: meta.examples
 		});
-		return isCyclic(schema) ? ast.lazyGetter({
+		return isCyclic(schema) ? lazyGetter({
 			name: propName,
 			body: value
-		}) : `${ast.objectKey(propName)}: ${value}`;
-	});
-	return ast.buildObject(entries);
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
 }
 /**
 * Zod v4 printer built with `definePrinter`.
@@ -784,7 +939,7 @@ const printerZod = ast.createPrinter((options) => {
 				if (!node.name) return null;
 				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.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;
+				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.schema.inputName(refName) ?? refName : this.options.resolver?.name(refName) ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
@@ -823,8 +978,7 @@ const printerZod = ast.createPrinter((options) => {
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				const items = ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean);
-				return `z.tuple(${ast.buildList(items)})`;
+				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
@@ -832,8 +986,8 @@ const printerZod = ast.createPrinter((options) => {
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
-				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${ast.stringify(node.discriminatorPropertyName)}, ${ast.buildList(members)})`;
-				return `z.union(${ast.buildList(members)})`;
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -905,7 +1059,7 @@ function buildZodMiniObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
 	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	const entries = ast.mapSchemaProperties(objectNode, (schema) => {
+	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -923,12 +1077,11 @@ function buildZodMiniObjectShape(ctx, node) {
 			nullish: schema.nullish,
 			defaultValue: meta.default
 		});
-		return isCyclic(schema) ? ast.lazyGetter({
+		return isCyclic(schema) ? lazyGetter({
 			name: propName,
 			body: value
-		}) : `${ast.objectKey(propName)}: ${value}`;
-	});
-	return ast.buildObject(entries);
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
 }
 /**
 * Zod v4 Mini printer built with `definePrinter`.
@@ -1013,7 +1166,7 @@ const printerZodMini = ast.createPrinter((options) => {
 			ref(node) {
 				if (!node.name) return null;
 				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.extractRefName(node.ref) ?? node.name : node.name;
-				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				const resolvedName = node.ref ? this.options.resolver?.name(refName) ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
@@ -1050,8 +1203,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				const items = ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean);
-				return `z.tuple(${ast.buildList(items)})`;
+				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
@@ -1059,8 +1211,8 @@ const printerZodMini = ast.createPrinter((options) => {
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
-				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${ast.stringify(node.discriminatorPropertyName)}, ${ast.buildList(members)})`;
-				return `z.union(${ast.buildList(members)})`;
+				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
+				return `z.union(${buildList(members)})`;
 			},
 			intersection(node) {
 				const members = node.members ?? [];
@@ -1180,22 +1332,20 @@ const zodGenerator = defineGenerator({
 		const hasCodec = !mini && containsCodec(node);
 		const codecRefNames = new Set(hasCodec ? collectCodecRefNames(node) : []);
 		const importEntries = adapter.getImports(node, (schemaName) => ({
-			name: resolver.resolveSchemaName(schemaName),
-			path: resolver.resolveFile({
+			name: resolver.name(schemaName),
+			path: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
 			}).path
 		}));
 		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
-			name: [resolver.resolveInputSchemaName(schemaName)],
-			path: resolver.resolveFile({
+			name: [resolver.schema.inputName(schemaName)],
+			path: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
@@ -1209,17 +1359,16 @@ const zodGenerator = defineGenerator({
 			return true;
 		});
 		const meta = {
-			name: resolver.resolveSchemaName(node.name),
-			file: resolver.resolveFile({
+			name: resolver.name(node.name),
+			file: resolver.file({
 				name: node.name,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
 			})
 		};
-		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null;
+		const inferTypeName = inferred ? resolver.schema.typeName(node.name) : null;
 		const nameMapping = adapter.options.nameMapping;
 		const stdPrinters = mini ? null : getStdPrinters(resolver, {
 			coercion,
@@ -1241,7 +1390,7 @@ const zodGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1249,7 +1398,7 @@ const zodGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1280,10 +1429,10 @@ const zodGenerator = defineGenerator({
 					cyclic: cyclicSchemas.has(node.name)
 				}),
 				hasCodec && stdPrinters && /* @__PURE__ */ jsx(Zod, {
-					name: resolver.resolveInputSchemaName(node.name),
+					name: resolver.schema.inputName(node.name),
 					node,
 					printer: stdPrinters.input,
-					inferTypeName: inferred ? resolver.resolveInputSchemaTypeName(node.name) : null,
+					inferTypeName: inferred ? resolver.schema.inputTypeName(node.name) : null,
 					cyclic: cyclicSchemas.has(node.name)
 				})
 			]
@@ -1296,12 +1445,11 @@ const zodGenerator = defineGenerator({
 		const dateType = adapter.options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const params = caseParams(node.parameters, "camelcase");
-		const meta = { file: resolver.resolveFile({
+		const meta = { file: resolver.file({
 			name: node.operationId,
 			extname: ".ts",
 			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
+			path: node.path,
 			root,
 			output,
 			group: group ?? void 0
@@ -1310,14 +1458,13 @@ const zodGenerator = defineGenerator({
 		const nameMapping = adapter.options.nameMapping;
 		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
 			if (!schema) return null;
-			const inferTypeName = inferred ? resolver.resolveTypeName(name) : null;
+			const inferTypeName = inferred ? resolver.schema.type(name) : 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({
+				name: codecRefNames?.has(schemaName) ? resolver.schema.inputName(schemaName) : resolver.name(schemaName),
+				path: resolver.file({
 					name: schemaName,
-					extname: ".ts"
-				}, {
+					extname: ".ts",
 					root,
 					output,
 					group: group ?? void 0
@@ -1393,64 +1540,55 @@ const zodGenerator = defineGenerator({
 				direction
 			})] });
 		}
+		function buildResponseUnion({ responses, name, fallbackUnknown }) {
+			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
+				name: resolver.name(schemaName),
+				path: ""
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(name)) return null;
+			const members = responses.map((res) => ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.status(node, res.statusCode)
+			}));
+			if (fallbackUnknown && members.length === 0) return renderSchemaEntry({
+				schema: ast.factory.createSchema({ type: "unknown" }),
+				name
+			});
+			return renderSchemaEntry({
+				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
+					type: "union",
+					members
+				}),
+				name
+			});
+		}
 		const paramSchemas = params.map((param) => renderSchemaEntry({
 			schema: param.schema,
-			name: resolver.resolveParamName(node, param),
+			name: resolver.param.name(node, param),
 			direction: "input"
 		}));
 		const responseSchemas = node.responses.map((res) => {
 			const variants = (res.content ?? []).filter((entry) => entry.schema);
-			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.resolveResponseStatusName(node, res.statusCode));
+			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.response.status(node, res.statusCode));
 			const primary = variants[0] ?? res.content?.[0];
 			return renderSchemaEntry({
 				schema: primary?.schema ?? null,
-				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				name: resolver.response.status(node, res.statusCode),
 				keysToOmit: primary?.keysToOmit
 			});
 		});
 		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 		const successResponsesWithSchema = getSuccessResponses(responsesWithSchema);
-		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
-			const responseUnionName = resolver.resolveResponseName(node);
-			if (new Set(successResponsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseUnionName)) return null;
-			const members = successResponsesWithSchema.map((res) => ast.factory.createSchema({
-				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
-			}));
-			if (members.length === 0) return renderSchemaEntry({
-				schema: ast.factory.createSchema({ type: "unknown" }),
-				name: responseUnionName
-			});
-			return renderSchemaEntry({
-				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
-					type: "union",
-					members
-				}),
-				name: responseUnionName
-			});
-		})() : null;
+		const responseUnionSchema = responsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: successResponsesWithSchema,
+			name: resolver.response.response(node),
+			fallbackUnknown: true
+		}) : null;
 		const errorResponsesWithSchema = responsesWithSchema.filter((res) => !isSuccessStatusCode(res.statusCode));
-		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? (() => {
-			const errorUnionName = resolver.resolveErrorName(node);
-			if (new Set(errorResponsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(errorUnionName)) return null;
-			const members = errorResponsesWithSchema.map((res) => ast.factory.createSchema({
-				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
-			}));
-			return renderSchemaEntry({
-				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
-					type: "union",
-					members
-				}),
-				name: errorUnionName
-			});
-		})() : null;
+		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? buildResponseUnion({
+			responses: errorResponsesWithSchema,
+			name: resolver.response.error(node),
+			fallbackUnknown: false
+		}) : null;
 		const requestBodyContent = node.requestBody?.content ?? [];
 		const requestSchema = (() => {
 			if (requestBodyContent.length === 0) return null;
@@ -1462,12 +1600,12 @@ const zodGenerator = defineGenerator({
 						...entry.schema,
 						description: node.requestBody.description ?? entry.schema.description
 					},
-					name: resolver.resolveDataName(node),
+					name: resolver.response.body(node),
 					keysToOmit: entry.keysToOmit,
 					direction: "input"
 				});
 			}
-			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({
 				...schema,
 				description: node.requestBody.description ?? schema.description
 			}), "input");
@@ -1476,7 +1614,7 @@ const zodGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1484,7 +1622,7 @@ const zodGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1520,64 +1658,63 @@ const zodGenerator = defineGenerator({
 * ```ts
 * import { resolverZod } from '@kubb/plugin-zod'
 *
-* resolverZod.default('list pets', 'function') // 'listPetsSchema'
-* resolverZod.resolveSchemaTypeName('pet')     // 'PetSchemaType'
+* resolverZod.name('list pets')          // 'listPetsSchema'
+* resolverZod.schema.typeName('pet')     // 'PetSchemaType'
 * ```
 */
-const resolverZod = defineResolver(() => {
-	return {
-		name: "default",
-		pluginName: "plugin-zod",
-		default(name, type) {
-			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) {
+const resolverZod = createResolver({
+	pluginName: "plugin-zod",
+	name(name) {
+		return ensureValidVarName(camelCase(name, { suffix: "schema" }));
+	},
+	file: { baseName({ name, extname }) {
+		return `${toFilePath(name, (part) => camelCase(part, { suffix: "schema" }))}${extname}`;
+	} },
+	schema: {
+		typeName(name) {
 			return ensureValidVarName(pascalCase(name, { suffix: "schema type" }));
 		},
-		resolveInputSchemaName(name) {
-			return this.resolveSchemaName(`${name} input`);
-		},
-		resolveInputSchemaTypeName(name) {
-			return this.resolveSchemaTypeName(`${name} input`);
-		},
-		resolveTypeName(name) {
+		type(name) {
 			return ensureValidVarName(pascalCase(name, { suffix: "type" }));
 		},
-		resolvePathName(name, type) {
-			return this.default(name, type);
+		inputName(name) {
+			return this.name(`${name} input`);
 		},
-		resolveParamName(node, param) {
-			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		resolveResponseStatusName(node, statusCode) {
-			return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`);
+		inputTypeName(name) {
+			return this.schema.typeName(`${name} input`);
+		}
+	},
+	param: {
+		name(node, param) {
+			return this.name(`${node.operationId} ${param.in} ${param.name}`);
 		},
-		resolveDataName(node) {
-			return this.resolveSchemaName(`${node.operationId} Data`);
+		path(node, param) {
+			return this.param.name(node, param);
 		},
-		resolveResponsesName(node) {
-			return this.resolveSchemaName(`${node.operationId} Responses`);
+		query(node, param) {
+			return this.param.name(node, param);
 		},
-		resolveResponseName(node) {
-			return this.resolveSchemaName(`${node.operationId} Response`);
+		headers(node, param) {
+			return this.param.name(node, param);
+		}
+	},
+	response: {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
 		},
-		resolveErrorName(node) {
-			return this.resolveSchemaName(`${node.operationId} Error`);
+		body(node) {
+			return this.name(`${node.operationId} Body`);
 		},
-		resolvePathParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
 		},
-		resolveQueryParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		response(node) {
+			return this.name(`${node.operationId} Response`);
 		},
-		resolveHeaderParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		error(node) {
+			return this.name(`${node.operationId} Error`);
 		}
-	};
+	}
 });
 //#endregion
 //#region src/plugin.ts
@@ -1636,10 +1773,7 @@ const pluginZod = definePlugin((options) => {
 				mini,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverZod,
-				...userResolver
-			} : resolverZod);
+			ctx.setResolver(userResolver ? Resolver.merge(resolverZod, userResolver) : resolverZod);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(zodGenerator);
 		} }