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

package/dist/index.js

@@ -1,10 +1,9 @@
 import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
-import { extractRefName, isStringType, jsStringEscape, mapSchemaItems, mapSchemaProperties, stringify, syncSchemaRef, trimQuotes } from "@kubb/ast/utils";
 import { parserTs } from "@kubb/parser-ts";
-import { File, jsxRenderer } from "@kubb/renderer-jsx";
+import { File, jsxRenderer } from "kubb/jsx";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import ts from "typescript";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -216,6 +215,67 @@ function ensureValidVarName(name) {
 	return `_${name}`;
 }
 //#endregion
+//#region ../../internals/utils/src/strings.ts
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* ```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, "\\'")}'`;
+}
+/**
+* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+* and the Unicode line terminators U+2028 and U+2029.
+*
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+*
+* @example
+* ```ts
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+//#endregion
 //#region src/constants.ts
 /**
 * `optionalType` values that cause a property's type to include `| undefined`.
@@ -756,7 +816,7 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = syncSchemaRef(schema);
+	const meta = ast.syncSchemaRef(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
@@ -800,10 +860,10 @@ function buildIndexSignatures(node, propertyCount, print) {
 * resolve to the same name, which TypeScript merges into a single value+type declaration.
 */
 function getEnumNames({ node, enum: enumOptions, resolver }) {
-	const resolved = resolver.resolveTypeName(node.name);
+	const resolved = resolver.name(node.name);
 	return {
 		enumName: enumOptions.constCasing === "pascalCase" ? resolved : camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolved
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved
 	};
 }
 /**
@@ -1002,7 +1062,7 @@ function isSchemaOptional(schema) {
 	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
 }
 function buildPropertyJSDocComments(schema, optional) {
-	const meta = syncSchemaRef(schema);
+	const meta = ast.syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
 	const hasDescription = meta && "description" in meta && meta.description;
 	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
@@ -1019,21 +1079,25 @@ function buildPropertyJSDocComments(schema, optional) {
 		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
-function buildParams(node, { params, resolver }) {
+/**
+* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
+* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
+* separate per-param type — the group itself is the only type these params get exported as.
+*/
+function buildParams({ params }) {
 	return ast.factory.createSchema({
 		type: "object",
 		properties: params.map((param) => ast.factory.createProperty({
 			name: param.name,
 			required: param.required,
 			schema: ast.factory.createSchema({
-				type: "ref",
-				name: resolver.resolveParamName(node, param),
+				...param.schema,
 				optional: !param.required
 			})
 		}))
 	});
 }
-function buildData(node, { resolver }) {
+function buildOptions(node, { resolver }) {
 	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing: "original" });
 	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
 	const hasRequiredPath = pathParams.some((param) => param.required);
@@ -1048,7 +1112,7 @@ function buildData(node, { resolver }) {
 				required: hasBody,
 				schema: hasBody ? ast.factory.createSchema({
 					type: "ref",
-					name: resolver.resolveDataName(node)
+					name: resolver.response.body(node)
 				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
@@ -1059,10 +1123,8 @@ function buildData(node, { resolver }) {
 				name: "path",
 				required: hasRequiredPath,
 				schema: pathParams.length > 0 ? ast.factory.createSchema({
-					...buildParams(node, {
-						params: pathParams,
-						resolver
-					}),
+					type: "ref",
+					name: resolver.param.path(node, pathParams[0]),
 					optional: !hasRequiredPath
 				}) : ast.factory.createSchema({
 					type: "never",
@@ -1074,10 +1136,8 @@ function buildData(node, { resolver }) {
 				name: "query",
 				required: hasRequiredQuery,
 				schema: queryParams.length > 0 ? ast.factory.createSchema({
-					...buildParams(node, {
-						params: queryParams,
-						resolver
-					}),
+					type: "ref",
+					name: resolver.param.query(node, queryParams[0]),
 					optional: !hasRequiredQuery
 				}) : ast.factory.createSchema({
 					type: "never",
@@ -1089,10 +1149,8 @@ function buildData(node, { resolver }) {
 				name: "headers",
 				required: hasRequiredHeader,
 				schema: headerParams.length > 0 ? ast.factory.createSchema({
-					...buildParams(node, {
-						params: headerParams,
-						resolver
-					}),
+					type: "ref",
+					name: resolver.param.headers(node, headerParams[0]),
 					optional: !hasRequiredHeader
 				}) : ast.factory.createSchema({
 					type: "never",
@@ -1110,7 +1168,7 @@ function buildData(node, { resolver }) {
 * query hooks and `result.data` use.
 */
 function buildResponseRecordEntry(node, res, resolver) {
-	const statusName = resolver.resolveResponseStatusName(node, res.statusCode);
+	const statusName = resolver.response.status(node, res.statusCode);
 	const variants = (res.content ?? []).filter((entry) => entry.schema);
 	if (variants.length <= 1) return ast.factory.createSchema({
 		type: "ref",
@@ -1155,7 +1213,7 @@ function buildResponseUnion(node, { resolver }) {
 		type: "union",
 		members: responsesWithSchema.map((res) => ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, res.statusCode)
+			name: resolver.response.status(node, res.statusCode)
 		}))
 	});
 }
@@ -1248,8 +1306,8 @@ const printerTs = ast.createPrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? extractRefName(node.ref) ?? node.name : node.name;
-				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.resolveTypeName(refName) : refName, void 0);
+				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? ast.extractRefName(node.ref) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName, void 0);
 			},
 			enum(node) {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
@@ -1257,18 +1315,18 @@ const printerTs = ast.createPrinter((options) => {
 					withParentheses: true,
 					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)
 				}) ?? void 0;
-				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix) : this.options.resolver.resolveTypeName(node.name), void 0);
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.enum.keyName(node, this.options.enum.typeSuffix) : this.options.resolver.name(node.name), void 0);
 			},
 			union(node) {
 				const members = node.members ?? [];
 				const hasStringLiteral = members.some((m) => {
 					return ast.narrowSchema(m, ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => isStringType(m));
+				const hasPlainString = members.some((m) => ast.isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (isStringType(m)) return createIntersectionDeclaration({
+						if (ast.isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1288,7 +1346,7 @@ const printerTs = ast.createPrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
+					nodes: ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1298,11 +1356,11 @@ const printerTs = ast.createPrinter((options) => {
 			object(node) {
 				const { transform, options } = this;
 				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
+				const propertyNodes = ast.mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
 					const baseType = output ?? keywordTypeNodes.unknown;
 					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
 					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
-					const propMeta = syncSchemaRef(property.schema);
+					const propMeta = ast.syncSchemaRef(property.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: optional ? addsQuestionToken : false,
@@ -1323,7 +1381,7 @@ const printerTs = ast.createPrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			if (!name) {
 				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
 				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
@@ -1369,15 +1427,14 @@ const typeGenerator = defineGenerator({
 		if (!node.name) return;
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
-			return resolver.resolveTypeName(schemaName);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.enum.keyName({ name: schemaName }, enumOptions.typeSuffix);
+			return resolver.name(schemaName);
 		}
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolveImportName(schemaName),
-			path: resolver.resolveFile({
+			path: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
@@ -1386,11 +1443,10 @@ const typeGenerator = defineGenerator({
 		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
 		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolver.resolveTypeName(node.name),
-			file: resolver.resolveFile({
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),
+			file: resolver.file({
 				name: node.name,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
@@ -1412,7 +1468,7 @@ const typeGenerator = 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: {
@@ -1420,7 +1476,7 @@ const typeGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1450,29 +1506,27 @@ const typeGenerator = defineGenerator({
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
 		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
 		}) };
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
-			return resolver.resolveTypeName(schemaName);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.enum.keyName({ name: schemaName }, enumOptions.typeSuffix);
+			return resolver.name(schemaName);
 		}
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
 				name: resolveImportName(schemaName),
-				path: resolver.resolveFile({
+				path: resolver.file({
 					name: schemaName,
-					extname: ".ts"
-				}, {
+					extname: ".ts",
 					root,
 					output,
 					group: group ?? void 0
@@ -1532,13 +1586,24 @@ const typeGenerator = defineGenerator({
 				name: baseName
 			})] });
 		}
-		const paramTypes = params.map((param) => renderSchemaType({
-			schema: {
-				...param.schema,
-				optional: !param.required
-			},
-			name: resolver.resolveParamName(node, param)
-		}));
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters({
+			...node,
+			parameters: params
+		}, { paramsCasing: "original" });
+		const paramGroupTypes = [
+			pathParams.length > 0 && renderSchemaType({
+				schema: buildParams({ params: pathParams }),
+				name: resolver.param.path(node, pathParams[0])
+			}),
+			queryParams.length > 0 && renderSchemaType({
+				schema: buildParams({ params: queryParams }),
+				name: resolver.param.query(node, queryParams[0])
+			}),
+			headerParams.length > 0 && renderSchemaType({
+				schema: buildParams({ params: headerParams }),
+				name: resolver.param.headers(node, headerParams[0])
+			})
+		];
 		const requestBodyContent = node.requestBody?.content ?? [];
 		function buildRequestType() {
 			if (requestBodyContent.length === 0) return null;
@@ -1550,11 +1615,11 @@ const typeGenerator = defineGenerator({
 						...entry.schema,
 						description: node.requestBody.description ?? entry.schema.description
 					},
-					name: resolver.resolveDataName(node),
+					name: resolver.response.body(node),
 					keysToOmit: entry.keysToOmit
 				});
 			}
-			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({
 				...schema,
 				description: node.requestBody.description ?? schema.description
 			}));
@@ -1562,29 +1627,29 @@ const typeGenerator = defineGenerator({
 		const requestType = buildRequestType();
 		const responseTypes = node.responses.map((res) => {
 			const variants = (res.content ?? []).filter((entry) => entry.schema);
-			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode));
+			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.response.status(node, res.statusCode));
 			const primary = variants[0] ?? res.content?.[0];
 			return renderSchemaType({
 				schema: primary?.schema ?? null,
-				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				name: resolver.response.status(node, res.statusCode),
 				keysToOmit: primary?.keysToOmit
 			});
 		});
-		const dataType = renderSchemaType({
-			schema: buildData({
+		const optionsType = renderSchemaType({
+			schema: buildOptions({
 				...node,
 				parameters: params
 			}, { resolver }),
-			name: resolver.resolveRequestConfigName(node)
+			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
 			schema: buildResponses(node, { resolver }),
-			name: resolver.resolveResponsesName(node)
+			name: resolver.response.responses(node)
 		});
 		function buildResponseType() {
 			const hasSchema = (res) => (res.content ?? []).some((entry) => entry.schema);
 			if (!node.responses.some(hasSchema)) return null;
-			const responseName = resolver.resolveResponseName(node);
+			const responseName = resolver.response.response(node);
 			const responsesWithSchema = node.responses.filter(hasSchema);
 			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
 				name: resolveImportName(schemaName),
@@ -1603,7 +1668,7 @@ const typeGenerator = 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: {
@@ -1611,7 +1676,7 @@ const typeGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1620,10 +1685,10 @@ const typeGenerator = defineGenerator({
 				}
 			}),
 			children: [
-				paramTypes,
+				paramGroupTypes,
 				responseTypes,
 				requestType,
-				dataType,
+				optionsType,
 				responsesType,
 				responseType
 			]
@@ -1638,64 +1703,61 @@ const typeGenerator = defineGenerator({
 * to reference the exact names `plugin-ts` produces without duplicating the
 * casing/file-layout rules.
 *
-* The `default` method is supplied by `defineResolver`. It uses PascalCase for
-* type names and PascalCase file paths (dotted names become `/`-joined) for files.
+* The `default` helpers are supplied by `createResolver`. This plugin overrides the top-level `name`
+* to use PascalCase for value and type names and `file` to write PascalCase file paths (dotted names
+* become `/`-joined), and groups the operation-specific naming under the `param`, `response`, and
+* `enum` namespaces.
 *
 * @example Resolve a type and file name
 * ```ts
 * import { resolverTs } from '@kubb/plugin-ts'
 *
-* resolverTs.default('list pets', 'type')        // 'ListPets'
-* resolverTs.resolvePathName('list pets', 'file') // 'ListPets'
-* resolverTs.resolveResponseStatusName(node, 200) // 'ListPetsStatus200'
+* resolverTs.name('list pets')                     // 'ListPets'
+* resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
 * ```
 */
-const resolverTs = defineResolver(() => {
-	return {
-		name: "default",
-		pluginName: "plugin-ts",
-		default(name, type) {
-			if (type === "file") return toFilePath(name, pascalCase);
-			return ensureValidVarName(pascalCase(name));
-		},
-		resolveTypeName(name) {
-			return ensureValidVarName(pascalCase(name));
-		},
-		resolvePathName(name, type) {
-			if (type === "file") return toFilePath(name, pascalCase);
-			return ensureValidVarName(pascalCase(name));
-		},
-		resolveParamName(node, param) {
-			return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		resolveResponseStatusName(node, statusCode) {
-			return this.resolveTypeName(`${node.operationId} Status ${statusCode}`);
-		},
-		resolveDataName(node) {
-			return this.resolveTypeName(`${node.operationId} Data`);
+const resolverTs = createResolver({
+	pluginName: "plugin-ts",
+	name(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	file: { baseName({ name, extname }) {
+		return `${toFilePath(name, pascalCase)}${extname}`;
+	} },
+	param: {
+		name(node, param) {
+			return this.name(`${node.operationId} ${param.in} ${param.name}`);
 		},
-		resolveRequestConfigName(node) {
-			return this.resolveTypeName(`${node.operationId} RequestConfig`);
+		path(node) {
+			return this.name(`${node.operationId} Path`);
 		},
-		resolveResponsesName(node) {
-			return this.resolveTypeName(`${node.operationId} Responses`);
+		query(node) {
+			return this.name(`${node.operationId} Query`);
 		},
-		resolveResponseName(node) {
-			return this.resolveTypeName(`${node.operationId} Response`);
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	},
+	response: {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
 		},
-		resolveEnumKeyName(node, enumTypeSuffix = "key") {
-			return `${this.resolveTypeName(node.name ?? "")}${enumTypeSuffix}`;
+		options(node) {
+			return this.name(`${node.operationId} Options`);
 		},
-		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);
+		body(node) {
+			return this.name(`${node.operationId} Body`);
 		}
-	};
+	},
+	enum: { keyName(node, enumTypeSuffix = "key") {
+		return `${this.name(node.name ?? "")}${enumTypeSuffix}`;
+	} }
 });
 //#endregion
 //#region src/plugin.ts
@@ -1712,7 +1774,7 @@ const pluginTsName = "plugin-ts";
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
+* import { defineConfig } from 'kubb/config'
 * import { pluginTs } from '@kubb/plugin-ts'
 *
 * export default defineConfig({
@@ -1756,10 +1818,7 @@ const pluginTs = definePlugin((options) => {
 				syntaxType,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverTs,
-				...userResolver
-			} : resolverTs);
+			ctx.setResolver(userResolver ? Resolver.merge(resolverTs, userResolver) : resolverTs);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(typeGenerator);
 		} }
@@ -2020,12 +2079,12 @@ function functionPrinter(options) {
 */
 function resolveParamType({ node, param, resolver }) {
 	if (!resolver) return param.schema.primitive ?? "unknown";
-	const individualName = resolver.resolveParamName(node, param);
+	const individualName = resolver.param.name(node, param);
 	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
 	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
+		path: resolver.param.path,
+		query: resolver.param.query,
+		header: resolver.param.headers
 	};
 	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
 	if (groupName && groupName !== individualName) return createIndexedAccessType({
@@ -2043,8 +2102,8 @@ function resolveParamType({ node, param, resolver }) {
 function resolveGroupType({ node, params, group, resolver }) {
 	if (!resolver || !params.length) return null;
 	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
+	const groupName = (group === "query" ? resolver.param.query : resolver.param.headers).call(resolver, node, firstParam);
+	if (groupName === resolver.param.name(node, firstParam)) return null;
 	return {
 		type: groupName,
 		optional: params.every((p) => !p.required)
@@ -2080,7 +2139,7 @@ function createOperationParams(node, options) {
 		optional: !param.required
 	});
 	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.response.body(node) ?? "unknown") : void 0;
 	const bodyProperty = bodyType ? [{
 		name: dataName,
 		type: bodyType,
@@ -2124,7 +2183,7 @@ function createOperationParams(node, options) {
 		}));
 	} else {
 		if (pathParamsType === "inlineSpread" && pathParams.length) {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
+			const spreadType = resolver?.param.path(node, pathParams[0]);
 			params.push(createFunctionParameter({
 				name: pathName,
 				type: spreadType ? wrapType(spreadType) : void 0,
@@ -2192,6 +2251,6 @@ function buildTypeLiteral({ node, params, resolver }) {
 	})) });
 }
 //#endregion
-export { Enum, Type, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
+export { Enum, Type, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 
 //# sourceMappingURL=index.js.map