@kubb/plugin-zod 5.0.0-beta.81 → 5.0.0-beta.85

package/dist/index.js

@@ -1,8 +1,7 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.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";
-import { buildList, buildObject, containsCircularRef, extractRefName, lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties, objectKey, stringify, syncSchemaRef, toRegExpString } from "@kubb/ast/utils";
+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
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -42,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.
@@ -189,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();
@@ -386,12 +542,12 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	if (hasCodec(node)) return true;
 	if (node.type === "ref") {
 		if (!node.ref) return false;
-		const refName = extractRefName(node.ref);
+		const refName = ast.extractRefName(node.ref);
 		if (refName) {
 			if (seen.has(refName)) return false;
 			seen.add(refName);
 		}
-		const resolved = syncSchemaRef(node);
+		const resolved = ast.syncSchemaRef(node);
 		if (resolved.type === "ref") return false;
 		return containsCodec(resolved, seen);
 	}
@@ -407,7 +563,7 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 * 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 });
+	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 });
 }
 /**
 * Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
@@ -428,9 +584,9 @@ function isObjectSchemaNode(node, cyclicSchemas) {
 	if (node.nullable || node.optional || node.nullish) return false;
 	if (node.type === "object") return true;
 	if (node.type === "ref") {
-		const refName = (node.ref ? extractRefName(node.ref) : void 0) ?? node.name;
+		const refName = (node.ref ? ast.extractRefName(node.ref) : void 0) ?? node.name;
 		if (refName && cyclicSchemas?.has(refName)) return false;
-		const resolved = syncSchemaRef(node);
+		const resolved = ast.syncSchemaRef(node);
 		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
 	}
 	if (node.type === "union") {
@@ -636,9 +792,9 @@ function strictOneOfMember$1(member, node, cyclicSchemas) {
 	if (node.type === "object" && node.additionalProperties === void 0) return `${member}.strict()`;
 	if (node.type === "ref") {
 		if (member.startsWith("z.lazy(")) return member;
-		const refName = (node.ref ? extractRefName(node.ref) : void 0) ?? node.name;
+		const refName = (node.ref ? ast.extractRefName(node.ref) : void 0) ?? node.name;
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = syncSchemaRef(node);
+		const schema = ast.syncSchemaRef(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
 		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
@@ -663,8 +819,8 @@ function getMemberConstraint({ member, regexType }) {
 function buildZodObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -673,7 +829,7 @@ function buildZodObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = syncSchemaRef(schema);
+		const meta = ast.syncSchemaRef(schema);
 		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 		const value = applyModifiers({
 			value: baseOutput,
@@ -781,9 +937,9 @@ const printerZod = ast.createPrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
+				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;
 			},
@@ -815,18 +971,18 @@ const printerZod = ast.createPrinter((options) => {
 				})();
 			},
 			array(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({
+				const base = `z.array(${ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthConstraints({
 					...node,
 					regexType: this.options.regexType
 				})}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
+				const members = ast.mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
@@ -857,7 +1013,7 @@ const printerZod = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			return applyModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -902,8 +1058,8 @@ function getMemberConstraintMini({ member, regexType }) {
 function buildZodMiniObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
-	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(ast.mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
 		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
@@ -912,7 +1068,7 @@ function buildZodMiniObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = syncSchemaRef(schema);
+		const meta = ast.syncSchemaRef(schema);
 		const value = applyMiniModifiers({
 			value: baseOutput,
 			schema,
@@ -1009,8 +1165,8 @@ const printerZodMini = ast.createPrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
-				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				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?.name(refName) ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
@@ -1040,18 +1196,18 @@ const printerZodMini = ast.createPrinter((options) => {
 				return objectBase;
 			},
 			array(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({
+				const base = `z.array(${ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(ast.factory.createSchema({ type: "unknown" }))})${lengthChecksMini({
 					...node,
 					regexType: this.options.regexType
 				})}`;
 				return node.unique ? `${base}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })` : base;
 			},
 			tuple(node) {
-				return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
+				return `z.tuple(${buildList(ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 			},
 			union(node) {
 				const nodeMembers = node.members ?? [];
-				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
+				const members = ast.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];
 				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
@@ -1082,7 +1238,7 @@ const printerZodMini = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			return applyMiniModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1176,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
@@ -1205,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,
@@ -1237,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: {
@@ -1245,7 +1398,7 @@ const zodGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1276,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)
 				})
 			]
@@ -1292,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
@@ -1306,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
@@ -1391,30 +1542,30 @@ const zodGenerator = defineGenerator({
 		}
 		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);
+			const responseUnionName = resolver.response.response(node);
 			if (new Set(successResponsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
+				name: resolver.name(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)
+				name: resolver.response.status(node, res.statusCode)
 			}));
 			if (members.length === 0) return renderSchemaEntry({
 				schema: ast.factory.createSchema({ type: "unknown" }),
@@ -1430,14 +1581,14 @@ const zodGenerator = defineGenerator({
 		})() : null;
 		const errorResponsesWithSchema = responsesWithSchema.filter((res) => !isSuccessStatusCode(res.statusCode));
 		const errorUnionSchema = errorResponsesWithSchema.length > 0 ? (() => {
-			const errorUnionName = resolver.resolveErrorName(node);
+			const errorUnionName = resolver.response.error(node);
 			if (new Set(errorResponsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
+				name: resolver.name(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)
+				name: resolver.response.status(node, res.statusCode)
 			}));
 			return renderSchemaEntry({
 				schema: members.length === 1 ? members[0] : ast.factory.createSchema({
@@ -1458,12 +1609,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");
@@ -1472,7 +1623,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: {
@@ -1480,7 +1631,7 @@ const zodGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1516,64 +1667,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);
-		},
-		resolveParamName(node, param) {
-			return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`);
+		inputName(name) {
+			return this.name(`${name} input`);
 		},
-		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
@@ -1591,7 +1741,7 @@ const pluginZodName = "plugin-zod";
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
+* import { defineConfig } from 'kubb/config'
 * import { pluginTs } from '@kubb/plugin-ts'
 * import { pluginZod } from '@kubb/plugin-zod'
 *
@@ -1632,10 +1782,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);
 		} }