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

package/dist/index.cjs

@@ -37,13 +37,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_parser_ts = require("@kubb/parser-ts");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
+let kubb_jsx = require("kubb/jsx");
+let kubb_kit = require("kubb/kit");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
-let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
-let _kubb_core = require("@kubb/core");
+let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -255,6 +254,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`.
@@ -795,7 +855,7 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = (0, _kubb_ast_utils.syncSchemaRef)(schema);
+	const meta = kubb_kit.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] });
@@ -839,10 +899,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
 	};
 }
 /**
@@ -866,21 +926,21 @@ function Enum({ node, enum: enumOptions, resolver }) {
 		name: enumName,
 		typeName,
 		enums: node.namedEnumValues?.map((v) => [
-			(0, _kubb_ast_utils.trimQuotes)(v.name.toString()),
+			trimQuotes(v.name.toString()),
 			v.value,
 			v.description
-		]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [(0, _kubb_ast_utils.trimQuotes)(v.toString()), v]) ?? [],
+		]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
 		type: enumOptions.type,
 		enumKeyCasing: enumOptions.keyCasing
 	});
 	const namesMerge = !!nameNode && enumName === typeName;
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name: enumName,
 		isExportable: true,
 		isIndexable: true,
 		isTypeOnly: false,
 		children: _kubb_parser_ts.parserTs.print(nameNode)
-	}), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+	}), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name: typeName,
 		isIndexable: !namesMerge,
 		isExportable: !namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type),
@@ -1041,99 +1101,97 @@ function isSchemaOptional(schema) {
 	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
 }
 function buildPropertyJSDocComments(schema, optional) {
-	const meta = (0, _kubb_ast_utils.syncSchemaRef)(schema);
+	const meta = kubb_kit.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}\``] : [];
 	const exampleValues = meta?.examples ?? [];
 	return [
-		hasDescription ? `@description ${(0, _kubb_ast_utils.jsStringEscape)(meta.description)}` : null,
+		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
 		...formatComment,
 		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
 		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
 		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
 		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? (0, _kubb_ast_utils.stringify)(meta.default) : meta.default}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : null,
 		...exampleValues.map((example) => `@example ${example}`),
 		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 }) {
-	return _kubb_core.ast.factory.createSchema({
+/**
+* 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 kubb_kit.ast.factory.createSchema({
 		type: "object",
-		properties: params.map((param) => _kubb_core.ast.factory.createProperty({
+		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
 			name: param.name,
 			required: param.required,
-			schema: _kubb_core.ast.factory.createSchema({
-				type: "ref",
-				name: resolver.resolveParamName(node, param),
+			schema: kubb_kit.ast.factory.createSchema({
+				...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);
 	const hasRequiredQuery = queryParams.some((param) => param.required);
 	const hasRequiredHeader = headerParams.some((param) => param.required);
-	return _kubb_core.ast.factory.createSchema({
+	return kubb_kit.ast.factory.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
-			_kubb_core.ast.factory.createProperty({
+			kubb_kit.ast.factory.createProperty({
 				name: "body",
 				required: hasBody,
-				schema: hasBody ? _kubb_core.ast.factory.createSchema({
+				schema: hasBody ? kubb_kit.ast.factory.createSchema({
 					type: "ref",
-					name: resolver.resolveDataName(node)
-				}) : _kubb_core.ast.factory.createSchema({
+					name: resolver.response.body(node)
+				}) : kubb_kit.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.factory.createProperty({
+			kubb_kit.ast.factory.createProperty({
 				name: "path",
 				required: hasRequiredPath,
-				schema: pathParams.length > 0 ? _kubb_core.ast.factory.createSchema({
-					...buildParams(node, {
-						params: pathParams,
-						resolver
-					}),
+				schema: pathParams.length > 0 ? kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: resolver.param.path(node, pathParams[0]),
 					optional: !hasRequiredPath
-				}) : _kubb_core.ast.factory.createSchema({
+				}) : kubb_kit.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.factory.createProperty({
+			kubb_kit.ast.factory.createProperty({
 				name: "query",
 				required: hasRequiredQuery,
-				schema: queryParams.length > 0 ? _kubb_core.ast.factory.createSchema({
-					...buildParams(node, {
-						params: queryParams,
-						resolver
-					}),
+				schema: queryParams.length > 0 ? kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: resolver.param.query(node, queryParams[0]),
 					optional: !hasRequiredQuery
-				}) : _kubb_core.ast.factory.createSchema({
+				}) : kubb_kit.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.factory.createProperty({
+			kubb_kit.ast.factory.createProperty({
 				name: "headers",
 				required: hasRequiredHeader,
-				schema: headerParams.length > 0 ? _kubb_core.ast.factory.createSchema({
-					...buildParams(node, {
-						params: headerParams,
-						resolver
-					}),
+				schema: headerParams.length > 0 ? kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: resolver.param.headers(node, headerParams[0]),
 					optional: !hasRequiredHeader
-				}) : _kubb_core.ast.factory.createSchema({
+				}) : kubb_kit.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
@@ -1149,27 +1207,27 @@ 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 _kubb_core.ast.factory.createSchema({
+	if (variants.length <= 1) return kubb_kit.ast.factory.createSchema({
 		type: "ref",
 		name: statusName
 	});
-	return _kubb_core.ast.factory.createSchema({
+	return kubb_kit.ast.factory.createSchema({
 		type: "union",
-		members: resolveContentTypeVariants(variants, statusName).map((variant) => _kubb_core.ast.factory.createSchema({
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => kubb_kit.ast.factory.createSchema({
 			type: "object",
-			properties: [_kubb_core.ast.factory.createProperty({
+			properties: [kubb_kit.ast.factory.createProperty({
 				name: "contentType",
 				required: true,
-				schema: _kubb_core.ast.factory.createSchema({
+				schema: kubb_kit.ast.factory.createSchema({
 					type: "enum",
 					enumValues: [variant.contentType]
 				})
-			}), _kubb_core.ast.factory.createProperty({
+			}), kubb_kit.ast.factory.createProperty({
 				name: "data",
 				required: true,
-				schema: _kubb_core.ast.factory.createSchema({
+				schema: kubb_kit.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				})
@@ -1178,9 +1236,9 @@ function buildResponseRecordEntry(node, res, resolver) {
 	});
 }
 function buildResponses(node, { resolver }) {
-	return _kubb_core.ast.factory.createSchema({
+	return kubb_kit.ast.factory.createSchema({
 		type: "object",
-		properties: node.responses.map((res) => _kubb_core.ast.factory.createProperty({
+		properties: node.responses.map((res) => kubb_kit.ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
 			schema: buildResponseRecordEntry(node, res, resolver)
@@ -1190,19 +1248,19 @@ function buildResponses(node, { resolver }) {
 function buildResponseUnion(node, { resolver }) {
 	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 	if (responsesWithSchema.length === 0) return null;
-	return _kubb_core.ast.factory.createSchema({
+	return kubb_kit.ast.factory.createSchema({
 		type: "union",
-		members: responsesWithSchema.map((res) => _kubb_core.ast.factory.createSchema({
+		members: responsesWithSchema.map((res) => kubb_kit.ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, res.statusCode)
+			name: resolver.response.status(node, res.statusCode)
 		}))
 	});
 }
 //#endregion
 //#region src/components/Type.tsx
 function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = _kubb_core.ast.collect(node, { schema(n) {
-		const enumNode = _kubb_core.ast.narrowSchema(n, _kubb_core.ast.schemaTypes.enum);
+	const enumSchemaNodes = kubb_kit.ast.collect(node, { schema(n) {
+		const enumNode = kubb_kit.ast.narrowSchema(n, kubb_kit.ast.schemaTypes.enum);
 		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
 	} });
 	const output = printer.print(node);
@@ -1219,11 +1277,11 @@ function Type({ name, node, printer, enum: enumOptions, resolver }) {
 	});
 	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
 	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Enum, {
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Enum, {
 		node,
 		enum: enumOptions,
 		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+	}, node.name)), shouldExportType && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name,
 		isTypeOnly: true,
 		isExportable: true,
@@ -1257,7 +1315,7 @@ const { isNonNullable } = factory_exports;
 * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
 * ```
 */
-const printerTs = _kubb_core.ast.createPrinter((options) => {
+const printerTs = kubb_kit.ast.createPrinter((options) => {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
 	return {
 		name: "typescript",
@@ -1287,8 +1345,8 @@ const printerTs = _kubb_core.ast.createPrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? (0, _kubb_ast_utils.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) ?? kubb_kit.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 ?? [];
@@ -1296,18 +1354,18 @@ const printerTs = _kubb_core.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 _kubb_core.ast.narrowSchema(m, _kubb_core.ast.schemaTypes.enum)?.primitive === "string";
+					return kubb_kit.ast.narrowSchema(m, kubb_kit.ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => (0, _kubb_ast_utils.isStringType)(m));
+				const hasPlainString = members.some((m) => kubb_kit.ast.isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if ((0, _kubb_ast_utils.isStringType)(m)) return createIntersectionDeclaration({
+						if (kubb_kit.ast.isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1327,7 +1385,7 @@ const printerTs = _kubb_core.ast.createPrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: (0, _kubb_ast_utils.mapSchemaItems)(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
+					nodes: kubb_kit.ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1337,11 +1395,11 @@ const printerTs = _kubb_core.ast.createPrinter((options) => {
 			object(node) {
 				const { transform, options } = this;
 				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = (0, _kubb_ast_utils.mapSchemaProperties)(node, (schema) => transform(schema)).map(({ name, property, output }) => {
+				const propertyNodes = kubb_kit.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 = (0, _kubb_ast_utils.syncSchemaRef)(property.schema);
+					const propMeta = kubb_kit.ast.syncSchemaRef(property.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: optional ? addsQuestionToken : false,
@@ -1362,7 +1420,7 @@ const printerTs = _kubb_core.ast.createPrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = (0, _kubb_ast_utils.syncSchemaRef)(node);
+			const meta = kubb_kit.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;
@@ -1399,37 +1457,35 @@ const printerTs = _kubb_core.ast.createPrinter((options) => {
 * types. Drop-replace with a custom `Generator<PluginTs>` to change how
 * TypeScript output is produced.
 */
-const typeGenerator = (0, _kubb_core.defineGenerator)({
+const typeGenerator = (0, kubb_kit.defineGenerator)({
 	name: "typescript",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: kubb_jsx.jsxRenderer,
 	schema(node, ctx) {
 		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
 		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
 			}).path
 		}));
-		const enumNode = _kubb_core.ast.narrowSchema(node, _kubb_core.ast.schemaTypes.enum);
+		const enumNode = kubb_kit.ast.narrowSchema(node, kubb_kit.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
@@ -1447,11 +1503,11 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			nameMapping: adapter.options.nameMapping,
 			nodes: printer?.nodes
 		});
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
 			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: {
@@ -1459,7 +1515,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1467,7 +1523,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			children: [imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			children: [imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1476,7 +1532,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				node.name,
 				imp.path,
 				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Type, {
+			].join("-"))), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Type, {
 				name: meta.name,
 				node,
 				enum: enumOptions,
@@ -1489,29 +1545,27 @@ const typeGenerator = (0, _kubb_core.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
@@ -1530,7 +1584,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				nameMapping: adapter.options.nameMapping,
 				nodes: printer?.nodes
 			});
-			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1539,7 +1593,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				name,
 				imp.path,
 				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Type, {
+			].join("-"))), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Type, {
 				name,
 				node: schema,
 				enum: enumOptions,
@@ -1555,14 +1609,14 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 		*/
 		function buildContentTypeVariants(entries, baseName, decorate) {
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = _kubb_core.ast.factory.createSchema({
+			const unionSchema = kubb_kit.ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => _kubb_core.ast.factory.createSchema({
+				members: variants.map((variant) => kubb_kit.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
 			});
-			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [variants.map((variant) => renderSchemaType({
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [variants.map((variant) => renderSchemaType({
 				schema: decorate ? decorate(variant.schema) : variant.schema,
 				name: variant.name,
 				keysToOmit: variant.keysToOmit
@@ -1571,13 +1625,24 @@ const typeGenerator = (0, _kubb_core.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;
@@ -1589,11 +1654,11 @@ const typeGenerator = (0, _kubb_core.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
 			}));
@@ -1601,29 +1666,29 @@ const typeGenerator = (0, _kubb_core.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),
@@ -1638,11 +1703,11 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			});
 		}
 		const responseType = buildResponseType();
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
 			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: {
@@ -1650,7 +1715,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1659,10 +1724,10 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				}
 			}),
 			children: [
-				paramTypes,
+				paramGroupTypes,
 				responseTypes,
 				requestType,
-				dataType,
+				optionsType,
 				responsesType,
 				responseType
 			]
@@ -1677,64 +1742,61 @@ const typeGenerator = (0, _kubb_core.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 = (0, _kubb_core.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 = (0, kubb_kit.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
@@ -1751,7 +1813,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({
@@ -1767,7 +1829,7 @@ const pluginTsName = "plugin-ts";
 * })
 * ```
 */
-const pluginTs = (0, _kubb_core.definePlugin)((options) => {
+const pluginTs = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "types",
 		barrel: { type: "named" }
@@ -1795,10 +1857,7 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 				syntaxType,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverTs,
-				...userResolver
-			} : resolverTs);
+			ctx.setResolver(userResolver ? kubb_kit.Resolver.merge(resolverTs, userResolver) : resolverTs);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(typeGenerator);
 		} }
@@ -2059,12 +2118,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({
@@ -2082,8 +2141,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)
@@ -2119,7 +2178,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,
@@ -2163,7 +2222,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,
@@ -2233,6 +2292,7 @@ function buildTypeLiteral({ node, params, resolver }) {
 //#endregion
 exports.Enum = Enum;
 exports.Type = Type;
+exports.buildParams = buildParams;
 exports.createFunctionParameter = createFunctionParameter;
 exports.createFunctionParameters = createFunctionParameters;
 exports.createIndexedAccessType = createIndexedAccessType;