@kubb/plugin-ts 5.0.0-beta.10 → 5.0.0-beta.100

package/dist/index.js

@@ -1,10 +1,9 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { safePrint } from "@kubb/parser-ts";
-import { File, jsxRenderer } from "@kubb/renderer-jsx";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { isNumber } from "remeda";
+import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
+import { parserTs } from "@kubb/parser-ts";
+import { File, jsxRenderer } from "kubb/jsx";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin, isStringType, syncSchemaRef } from "kubb/kit";
 import ts from "typescript";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -16,58 +15,41 @@ import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
 * Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 /**
 * Converts `text` to snake_case.
 *
-* @example
-* snakeCase('helloWorld')  // 'hello_world'
-* snakeCase('Hello-World') // 'hello_world'
+* @example From camelCase
+* `snakeCase('helloWorld') // 'hello_world'`
+*
+* @example From mixed separators
+* `snakeCase('Hello-World') // 'hello_world'`
 */
 function snakeCase(text, { prefix = "", suffix = "" } = {}) {
 	return `${prefix} ${text} ${suffix}`.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-.]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toLowerCase().split("_").filter(Boolean).join("_");
@@ -75,8 +57,8 @@ function snakeCase(text, { prefix = "", suffix = "" } = {}) {
 /**
 * Converts `text` to SCREAMING_SNAKE_CASE.
 *
-* @example
-* screamingSnakeCase('helloWorld') // 'HELLO_WORLD'
+* @example From camelCase
+* `screamingSnakeCase('helloWorld') // 'HELLO_WORLD'`
 */
 function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	return snakeCase(text, {
@@ -85,14 +67,155 @@ function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	}).toUpperCase();
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
+}
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
+*
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+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
 /**
 * 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) {
@@ -103,8 +226,24 @@ function trimQuotes(text) {
 	return text;
 }
 /**
-* Escapes characters that are not allowed inside JS string literals.
-* Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).
+* 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
 *
@@ -128,49 +267,59 @@ function jsStringEscape(input) {
 	});
 }
 //#endregion
-//#region ../../internals/utils/src/object.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
+* 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 stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(trimQuotes(value.toString()));
+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 src/constants.ts
 /**
 * `optionalType` values that cause a property's type to include `| undefined`.
 */
-const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined"]);
+const OPTIONAL_ADDS_UNDEFINED = /* @__PURE__ */ new Set(["undefined", "questionTokenAndUndefined"]);
 /**
 * `optionalType` values that render the property key with a `?` token.
 */
-const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
+const OPTIONAL_ADDS_QUESTION_TOKEN = /* @__PURE__ */ new Set(["questionToken", "questionTokenAndUndefined"]);
 /**
-* `enumType` values that append a `Key` suffix to the generated enum type alias.
+* `enum.type` values that append a `typeSuffix` to the generated enum type alias.
 */
-const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst", "asPascalConst"]);
+const ENUM_TYPES_WITH_KEY_SUFFIX = /* @__PURE__ */ new Set(["asConst"]);
 /**
-* `enumType` values that require a runtime value declaration (object, enum, or literal).
+* `enum.type` values that require a runtime value declaration (object, enum, or literal).
 */
-const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set([
+const ENUM_TYPES_WITH_RUNTIME_VALUE = /* @__PURE__ */ new Set([
 	"enum",
 	"asConst",
-	"asPascalConst",
 	"constEnum",
 	"literal",
 	void 0
 ]);
 /**
-* `enumType` values whose type declaration is type-only (no runtime value emitted for the type alias).
+* `enum.type` values whose type declaration is type-only (no runtime value emitted for the type alias).
 */
-const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
+const ENUM_TYPES_WITH_TYPE_ONLY = /* @__PURE__ */ new Set([
 	"asConst",
-	"asPascalConst",
 	"literal",
 	void 0
 ]);
@@ -185,8 +334,48 @@ const PARAM_RANK = {
 };
 //#endregion
 //#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	appendJSDocToNode: () => appendJSDocToNode,
+	buildIndexSignatures: () => buildIndexSignatures,
+	buildMemberNodes: () => buildMemberNodes,
+	buildPropertyType: () => buildPropertyType,
+	buildTupleNode: () => buildTupleNode,
+	constToTypeNode: () => constToTypeNode,
+	createArrayDeclaration: () => createArrayDeclaration,
+	createEnumDeclaration: () => createEnumDeclaration,
+	createExportDeclaration: () => createExportDeclaration,
+	createImportDeclaration: () => createImportDeclaration,
+	createIntersectionDeclaration: () => createIntersectionDeclaration,
+	createJSDoc: () => createJSDoc,
+	createOmitDeclaration: () => createOmitDeclaration,
+	createParameterSignature: () => createParameterSignature,
+	createPropertySignature: () => createPropertySignature,
+	createQuestionToken: () => createQuestionToken,
+	createTypeDeclaration: () => createTypeDeclaration,
+	createTypeLiteralNode: () => createTypeLiteralNode,
+	createTypeReferenceNode: () => createTypeReferenceNode,
+	createUnionDeclaration: () => createUnionDeclaration,
+	createUrlTemplateType: () => createUrlTemplateType,
+	dateOrStringNode: () => dateOrStringNode,
+	isNonNullable: () => isNonNullable$1,
+	keywordTypeNodes: () => keywordTypeNodes,
+	modifiers: () => modifiers,
+	syntaxKind: () => syntaxKind
+});
 const { SyntaxKind, factory } = ts;
 /**
+* Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
+* regardless of locale.
+*/
+function compareStrings(a, b) {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+function isNumber(value) {
+	return typeof value === "number" && !Number.isNaN(value);
+}
+/**
 * TypeScript AST modifiers for common keywords (async, export, const, static).
 */
 const modifiers = {
@@ -209,8 +398,13 @@ function isNonNullable$1(value) {
 __name(isNonNullable$1, "isNonNullable");
 function isValidIdentifier(str) {
 	if (!str.length || str.trim() !== str) return false;
-	const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
-	return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind) === void 0;
+	let ch = str.codePointAt(0);
+	if (!ts.isIdentifierStart(ch, ts.ScriptTarget.Latest)) return false;
+	for (let i = ch > 65535 ? 2 : 1; i < str.length; i += ch > 65535 ? 2 : 1) {
+		ch = str.codePointAt(i);
+		if (!ts.isIdentifierPart(ch, ts.ScriptTarget.Latest)) return false;
+	}
+	return true;
 }
 function propertyName(name) {
 	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -285,6 +479,17 @@ function createParameterSignature(name, { modifiers, dotDotDotToken, questionTok
 	return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer);
 }
 /**
+* Creates a JSDoc comment node from an array of comment strings.
+* Returns null if no comments are provided.
+*/
+function createJSDoc({ comments }) {
+	if (!comments.length) return null;
+	return factory.createJSDocComment(factory.createNodeArray(comments.map((comment, i) => {
+		if (i === comments.length - 1) return factory.createJSDocText(comment);
+		return factory.createJSDocText(`${comment}\n`);
+	})));
+}
+/**
 * Attaches JSDoc comments to an AST node as synthetic leading comments.
 * Filters out undefined comments before attaching.
 *
@@ -322,7 +527,7 @@ function createInterfaceDeclaration({ modifiers, name, typeParameters, members }
 * Intelligently selects the syntax based on the type structure and attaches JSDoc comments.
 */
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
+	if (syntax === "interface" && ts.isTypeLiteralNode(type)) return appendJSDocToNode({
 		node: createInterfaceDeclaration({
 			members: [...type.members],
 			modifiers: isExportable ? [modifiers.export] : [],
@@ -342,6 +547,50 @@ function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
 	});
 }
 /**
+* Creates an import declaration with support for default imports, named imports, namespace imports, and type-only imports.
+* Optionally rename imported members with `propertyName` and `name` pairs.
+*
+* @example Default import
+* `import Pet from './Pet'`
+*
+* @example Named imports with rename
+* `import { Pet as Cat } from './Pet'`
+*
+* @example Namespace import
+* `import * as Pet from './Pet'`
+*/
+function createImportDeclaration({ name, path, isTypeOnly = false, isNameSpace = false }) {
+	if (!Array.isArray(name)) {
+		const importPropertyName = isNameSpace ? void 0 : factory.createIdentifier(name);
+		const importName = isNameSpace ? factory.createNamespaceImport(factory.createIdentifier(name)) : void 0;
+		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, importPropertyName, importName), factory.createStringLiteral(path), void 0);
+	}
+	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "object" ? a.propertyName : a, typeof b === "object" ? b.propertyName : b));
+	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(sortedName.map((item) => {
+		if (typeof item === "object") {
+			const obj = item;
+			if (obj.name) return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name));
+			return factory.createImportSpecifier(false, void 0, factory.createIdentifier(obj.propertyName));
+		}
+		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
+	}))), factory.createStringLiteral(path), void 0);
+}
+/**
+* Creates an export declaration with support for named exports, namespace exports, and type-only exports.
+* Sorts export names alphabetically for consistent output across platforms.
+*/
+function createExportDeclaration({ path, asAlias, isTypeOnly = false, name }) {
+	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true ${name}`);
+	if (!Array.isArray(name)) {
+		const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
+		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
+	}
+	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "string" ? a : a.text, typeof b === "string" ? b : b.text));
+	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(sortedName.map((propertyName) => {
+		return factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName);
+	})), factory.createStringLiteral(path), void 0);
+}
+/**
 * Apply casing transformation to enum keys
 */
 function applyEnumKeyCasing(key, casing = "none") {
@@ -362,7 +611,7 @@ function applyEnumKeyCasing(key, casing = "none") {
 *   type: 'enum',
 *   name: 'petType',
 *   typeName: 'PetType',
-*   enums: [['cat', 'cat'], ['dog', 'dog']],
+*   enums: [['cat', 'cat', 'A cat'], ['dog', 'dog']],
 * })
 * ```
 */
@@ -373,32 +622,41 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 			return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
 		}
 		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
-		if (value) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
+		if (value !== null && value !== void 0) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
 	}).filter((node) => node !== void 0)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if (Number.parseInt(value.toString(), 10) === value && isNumber(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (isNumber(Number.parseInt(key.toString(), 10))) {
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createEnumMember(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
-		if (key) {
+		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createEnumMember(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createEnumMember(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
 	}).filter((member) => member !== void 0))];
 	const identifierName = name;
 	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
+	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
-		if (key) {
+		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
+			return appendJSDocToNode({
+				node: factory.createPropertyAssignment(propertyName(casingKey), initializer),
+				comments: [description]
+			});
 		}
 	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], ts.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
 }
@@ -482,12 +740,10 @@ const createStringLiteral = factory.createStringLiteral;
 * Creates an array type node (e.g., `T[]`).
 */
 const createArrayTypeNode = factory.createArrayTypeNode;
-factory.createParenthesizedType;
 /**
 * Creates a literal type node (e.g., `'hello'`, `42`, `true`).
 */
 const createLiteralTypeNode = factory.createLiteralTypeNode;
-factory.createNull;
 /**
 * Creates an identifier node.
 */
@@ -512,8 +768,6 @@ const createTrue = factory.createTrue;
 * Creates a boolean false literal type node.
 */
 const createFalse = factory.createFalse;
-factory.createIndexedAccessTypeNode;
-factory.createTypeOperatorNode;
 /**
 * Creates a prefix unary expression (e.g., negative numbers, logical not).
 */
@@ -561,32 +815,38 @@ function buildTupleNode(node, print) {
 /**
 * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
 */
-function buildPropertyType(schema, baseType, optionalType) {
+function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = ast.syncSchemaRef(schema);
+	const meta = syncSchemaRef(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-	if ((meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
+const indexSignaturePrinter = ts.createPrinter();
+const indexSignatureSource = ts.createSourceFile("", "", ts.ScriptTarget.Latest);
 /**
-* Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
+* Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an
+* object schema node. TypeScript allows only one string index signature and its value must be
+* assignable from every named property, so both keywords collapse into a single signature: the
+* union of all value types (deduplicated), or `unknown` when the object also has fixed properties.
+* The key regex of `patternProperties` cannot be expressed by an index signature and is dropped.
 */
 function buildIndexSignatures(node, propertyCount, print) {
-	const elements = [];
-	if (node.additionalProperties && node.additionalProperties !== true) {
-		const additionalType = print(node.additionalProperties) ?? keywordTypeNodes.unknown;
-		elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
-	} else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
-	if (node.patternProperties) {
-		const first = Object.values(node.patternProperties)[0];
-		if (first) {
-			let patternType = print(first) ?? keywordTypeNodes.unknown;
-			if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
-			elements.push(createIndexSignature(patternType));
-		}
+	const valueTypes = [];
+	if (node.additionalProperties && node.additionalProperties !== true) valueTypes.push(print(node.additionalProperties) ?? keywordTypeNodes.unknown);
+	else if (node.additionalProperties === true) valueTypes.push(keywordTypeNodes.unknown);
+	for (const schema of Object.values(node.patternProperties ?? {})) {
+		const patternType = print(schema) ?? keywordTypeNodes.unknown;
+		valueTypes.push(schema.nullable ? createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] }) : patternType);
 	}
-	return elements;
+	if (valueTypes.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const distinct = valueTypes.filter((type) => {
+		const key = indexSignaturePrinter.printNode(ts.EmitHint.Unspecified, type, indexSignatureSource);
+		return seen.has(key) ? false : (seen.add(key), true);
+	});
+	return [createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct }))];
 }
 //#endregion
 //#region src/components/Enum.tsx
@@ -594,236 +854,501 @@ function buildIndexSignatures(node, propertyCount, print) {
 * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
 *
 * The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
-* valid TypeScript identifier. The resolver normalizes it; for inline enum
-* properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
+* valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter
+* already emits a PascalCase+suffix name, so resolution is typically a no-op.
+*
+* When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
+* resolve to the same name, which TypeScript merges into a single value+type declaration.
 */
-function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
-	const resolved = resolver.default(node.name, "type");
+function getEnumNames({ node, enum: enumOptions, resolver }) {
+	const resolved = resolver.name(node.name);
 	return {
-		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
+		enumName: enumOptions.constCasing === "pascalCase" ? resolved : camelCase(node.name),
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved
 	};
 }
 /**
 * Renders the enum declaration(s) for a single named `EnumSchemaNode`.
 *
-* Depending on `enumType` this may emit:
-* - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
+* Depending on `enum.type` this may emit:
+* - A runtime object (`asConst`) plus a `typeof` type alias
 * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
 * - A union literal type alias (`literal`)
 *
 * The emitted `File.Source` nodes carry the resolved names so that the barrel
 * index picks up the correct export identifiers.
 */
-function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+function Enum({ node, enum: enumOptions, resolver }) {
 	const { enumName, typeName } = getEnumNames({
 		node,
-		enumType,
-		enumTypeSuffix,
+		enum: enumOptions,
 		resolver
 	});
 	const [nameNode, typeNode] = createEnumDeclaration({
 		name: enumName,
 		typeName,
-		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
-		type: enumType,
-		enumKeyCasing
+		enums: node.namedEnumValues?.map((v) => [
+			trimQuotes(v.name.toString()),
+			v.value,
+			v.description
+		]) ?? 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__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
 		name: enumName,
 		isExportable: true,
 		isIndexable: true,
 		isTypeOnly: false,
-		children: safePrint(nameNode)
+		children: parserTs().print(nameNode)
 	}), /* @__PURE__ */ jsx(File.Source, {
 		name: typeName,
-		isIndexable: true,
-		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
-		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-		children: safePrint(typeNode)
+		isIndexable: !namesMerge,
+		isExportable: !namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type),
+		children: parserTs().print(typeNode)
 	})] });
 }
 //#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
-	const enumSchemaNodes = ast.collect(node, { schema(n) {
-		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
-		if (enumNode?.name) return enumNode;
-	} });
-	const output = printer.print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
 		return {
-			node,
-			...getEnumNames({
-				node,
-				enumType,
-				enumTypeSuffix,
-				resolver
-			})
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
 		};
 	});
-	const shouldExportEnums = enumType !== "inlineLiteral";
-	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enumType,
-		enumTypeSuffix,
-		enumKeyCasing,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
+}
+function getOperationParameters(node) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function buildOptionsSchema(node, resolver) {
+	const { path, query, header } = getOperationParameters(node);
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const createNever = () => ast.factory.createSchema({
+		type: "never",
+		primitive: void 0,
+		optional: true
+	});
+	const groups = [
+		{
+			name: "path",
+			params: path,
+			resolve: resolver.param.path
+		},
+		{
+			name: "query",
+			params: query,
+			resolve: resolver.param.query
+		},
+		{
+			name: "headers",
+			params: header,
+			resolve: resolver.param.headers
+		}
+	];
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? ast.factory.createSchema({
+					type: "ref",
+					name: resolve.call(resolver.param, node, params[0]),
+					optional: !required
+				}) : createNever()
+			});
+		})]
+	});
 }
 //#endregion
-//#region ../../internals/shared/src/operation.ts
-function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+//#region ../../internals/shared/src/resolver.ts
+/**
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
+*
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+function operationParamName(node, param) {
+	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+}
+/**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
+* ```
+*/
+function createOperationResponseResolver() {
 	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
 	};
 }
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/refs.ts
+/**
+* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
+* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
+* `resolver.imports` would resolve file paths that are then discarded.
+*/
+function collectRefNames(schema) {
+	return ast.collectSync(schema, { schema: (node) => {
+		const refNode = ast.narrowSchema(node, "ref");
+		if (!refNode?.ref) return null;
+		return ast.resolveRefName(refNode);
+	} });
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
 //#endregion
 //#region src/utils.ts
 /**
+* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
+* rather than a named enum reference or a runtime enum declaration.
+*
+* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
+* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
+* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
+* a named enum, which keeps the declaration and its references in sync across adapter versions.
+*/
+function isInlineConstEnum(node, enumSchemaNames) {
+	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
+}
+/**
 * Collects JSDoc annotation strings for a schema node.
 *
 * Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
 * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
 
 */
-function buildPropertyJSDocComments(schema) {
-	const meta = ast.syncSchemaRef(schema);
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
+}
+function formatExample(value) {
+	if (value === null || typeof value !== "object") return String(value);
+	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
-	return [
-		meta && "description" in meta && meta.description ? `@description ${jsStringEscape(meta.description)}` : void 0,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : void 0,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : void 0,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : void 0,
-		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : void 0,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : void 0,
-		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : void 0,
-		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+	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 ?? [];
+	const comments = [
+		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" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
+		...exampleValues.map((example) => `@example ${formatExample(example)}`)
 	].filter(Boolean);
+	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
+	return [...comments, typeTag].filter(Boolean);
 }
-function buildParams(node, { params, resolver }) {
-	return ast.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 ast.factory.createSchema({
 		type: "object",
-		properties: params.map((param) => ast.createProperty({
+		properties: params.map((param) => ast.factory.createProperty({
 			name: param.name,
 			required: param.required,
-			schema: ast.createSchema({
-				type: "ref",
-				name: resolver.resolveParamName(node, param)
+			schema: ast.factory.createSchema({
+				...param.schema,
+				optional: !param.required
 			})
 		}))
 	});
 }
-function buildData(node, { resolver }) {
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
-	return ast.createSchema({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			ast.createProperty({
-				name: "data",
-				schema: node.requestBody?.content?.[0]?.schema ? ast.createSchema({
-					type: "ref",
-					name: resolver.resolveDataName(node),
-					optional: true
-				}) : ast.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			ast.createProperty({
-				name: "pathParams",
-				required: pathParams.length > 0,
-				schema: pathParams.length > 0 ? buildParams(node, {
-					params: pathParams,
-					resolver
-				}) : ast.createSchema({
-					type: "never",
-					primitive: void 0
-				})
-			}),
-			ast.createProperty({
-				name: "queryParams",
-				schema: queryParams.length > 0 ? ast.createSchema({
-					...buildParams(node, {
-						params: queryParams,
-						resolver
-					}),
-					optional: true
-				}) : ast.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			ast.createProperty({
-				name: "headerParams",
-				schema: headerParams.length > 0 ? ast.createSchema({
-					...buildParams(node, {
-						params: headerParams,
-						resolver
-					}),
-					optional: true
-				}) : ast.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
+/**
+* The schema a status occupies in the `<Name>Responses` record. A status that documents several
+* content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
+* on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
+* query hooks and `result.data` use.
+*/
+function buildResponseRecordEntry(node, res, resolver) {
+	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",
+		name: statusName
+	});
+	return ast.factory.createSchema({
+		type: "union",
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => ast.factory.createSchema({
+			type: "object",
+			properties: [ast.factory.createProperty({
+				name: "contentType",
+				required: true,
+				schema: ast.factory.createSchema({
+					type: "enum",
+					enumValues: [variant.contentType]
 				})
-			}),
-			ast.createProperty({
-				name: "url",
+			}), ast.factory.createProperty({
+				name: "data",
 				required: true,
-				schema: ast.createSchema({
-					type: "url",
-					path: node.path
+				schema: ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
 				})
-			})
-		]
+			})]
+		}))
 	});
 }
 function buildResponses(node, { resolver }) {
-	if (node.responses.length === 0) return null;
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "object",
-		properties: node.responses.map((res) => ast.createProperty({
+		properties: node.responses.map((res) => ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: ast.createSchema({
-				type: "ref",
-				name: resolver.resolveResponseStatusName(node, res.statusCode)
-			})
+			schema: buildResponseRecordEntry(node, res, resolver)
 		}))
 	});
 }
 function buildResponseUnion(node, { resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 	if (responsesWithSchema.length === 0) return null;
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "union",
-		members: responsesWithSchema.map((res) => ast.createSchema({
+		members: responsesWithSchema.map((res) => ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, res.statusCode)
+			name: resolver.response.status(node, res.statusCode)
 		}))
 	});
 }
 //#endregion
-//#region src/printers/printerTs.ts
-function isNonNullable(value) {
-	return value !== null && value !== void 0;
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
+	const enumSchemaNodes = ast.collectSync(node, { schema(n) {
+		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
 }
+//#endregion
+//#region src/printers/printerTs.ts
+const { isNonNullable } = factory_exports;
 /**
 * TypeScript type printer built with `definePrinter`.
 *
@@ -837,17 +1362,17 @@ function isNonNullable(value) {
 *
 * @example Raw type node (no `typeName`)
 * ```ts
-* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
 * const typeNode = printer.print(schemaNode) // ts.TypeNode
 * ```
 *
 * @example Full declaration (with `typeName`)
 * ```ts
-* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral', typeName: 'MyType' })
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
 * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
 * ```
 */
-const printerTs = ast.definePrinter((options) => {
+const printerTs = ast.createPrinter((options) => {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
 	return {
 		name: "typescript",
@@ -876,28 +1401,31 @@ const printerTs = ast.definePrinter((options) => {
 			date: dateOrStringNode,
 			time: dateOrStringNode,
 			ref(node) {
-				if (!node.name) return;
-				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
-				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+				if (!node.name) return null;
+				const refName = ast.resolveRefName(node);
+				if (!refName) return null;
+				const name = 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;
+				return createTypeReferenceNode(name, void 0);
 			},
 			enum(node) {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
-				if (this.options.enumType === "inlineLiteral" || !node.name) return createUnionDeclaration({
+				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({
 					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.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
+				const resolvedName = 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);
+				return createTypeReferenceNode(resolvedName, 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) => ast.isStringType(m));
+				const hasPlainString = members.some((m) => isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (ast.isStringType(m)) return createIntersectionDeclaration({
+						if (isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -913,32 +1441,33 @@ const printerTs = ast.definePrinter((options) => {
 				return createIntersectionDeclaration({
 					withParentheses: true,
 					nodes: buildMemberNodes(node.members, this.transform)
-				}) ?? void 0;
+				}) ?? null;
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(isNonNullable),
+					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
-				}) ?? void 0;
+				}) ?? null;
 			},
 			tuple(node) {
-				return buildTupleNode(node, this.transform);
+				return buildTupleNode(node, this.transform) ?? null;
 			},
 			object(node) {
 				const { transform, options } = this;
 				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = node.properties.map((prop) => {
-					const baseType = transform(prop.schema) ?? keywordTypeNodes.unknown;
-					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
-					const propMeta = ast.syncSchemaRef(prop.schema);
+				const propertyNodes = 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);
 					return appendJSDocToNode({
 						node: createPropertySignature({
-							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-							name: prop.name,
+							questionToken: optional ? addsQuestionToken : false,
+							name,
 							type,
 							readOnly: propMeta?.readOnly
 						}),
-						comments: buildPropertyJSDocComments(prop.schema)
+						comments: buildPropertyJSDocComments(property.schema, optional)
 					});
 				});
 				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
@@ -949,91 +1478,91 @@ const printerTs = ast.definePrinter((options) => {
 		},
 		print(node) {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
-			const meta = ast.syncSchemaRef(node);
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = syncSchemaRef(node);
 			if (!name) {
-				if (meta.nullable) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.null] });
-				if ((meta.nullish || meta.optional) && addsUndefined) base = createUnionDeclaration({ nodes: [base, keywordTypeNodes.undefined] });
-				return safePrint(base);
+				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
+				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+				return parserTs().print(result);
 			}
-			let inner = keysToOmit?.length ? createOmitDeclaration({
-				keys: keysToOmit,
-				type: base,
-				nonNullable: true
-			}) : base;
-			if (meta.nullable) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.null] });
-			if (meta.nullish || meta.optional) inner = createUnionDeclaration({ nodes: [inner, keywordTypeNodes.undefined] });
-			const useTypeGeneration = syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length;
-			return safePrint(createTypeDeclaration({
+			const inner = (() => {
+				const omitted = keysToOmit?.length ? createOmitDeclaration({
+					keys: keysToOmit,
+					type: transformed,
+					nonNullable: true
+				}) : transformed;
+				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [omitted, keywordTypeNodes.null] }) : omitted;
+				return meta.nullish || meta.optional ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+			})();
+			const typeNode = createTypeDeclaration({
 				name,
 				isExportable: true,
 				type: inner,
-				syntax: useTypeGeneration ? "type" : "interface",
+				syntax: syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length ? "type" : "interface",
 				comments: buildPropertyJSDocComments({
 					...meta,
 					description
 				})
-			}));
+			});
+			return parserTs().print(typeNode);
 		}
 	};
 });
 //#endregion
 //#region src/generators/typeGenerator.tsx
-function getContentTypeSuffix(contentType) {
-	const baseType = contentType.split(";")[0].trim();
-	if (baseType === "application/json") return "Json";
-	if (baseType === "multipart/form-data") return "FormData";
-	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
-	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
-	if (parts.length === 0) return "Unknown";
-	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function getPerContentTypeName(dataName, suffix) {
-	if (dataName.endsWith("Data")) return suffix.endsWith("Data") ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`;
-	return dataName + suffix;
+/**
+* Resolves the imported type name for a referenced schema. An enum schema emitted
+* as a `const` object imports its suffixed key alias (e.g. `StatusKey`); every other
+* schema imports its plain resolved name.
+*/
+function resolveImportName({ schemaName, enumOptions, enumSchemaNames, resolver }) {
+	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);
 }
+/**
+* Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
+* schema in the spec plus per-operation request, response, and parameter
+* types. Drop-replace with a custom `Generator<PluginTs>` to change how
+* TypeScript output is produced.
+*/
 const typeGenerator = defineGenerator({
 	name: "typescript",
 	renderer: jsxRenderer,
 	schema(node, ctx) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
+		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
+		const { config, resolver, root } = ctx;
 		if (!node.name) return;
-		const mode = ctx.getMode(output);
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name));
-		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
-			return resolver.resolveTypeName(schemaName);
-		}
-		const imports = adapter.getImports(node, (schemaName) => ({
-			name: resolveImportName(schemaName),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group
-			}).path
-		}));
-		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
+		const imports = resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0,
+			name: importName
+		});
+		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
+		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : 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: group ?? void 0
 			})
 		};
 		const schemaPrinter = printerTs({
 			optionalType,
 			arrayType,
-			enumType,
-			enumTypeSuffix,
+			enum: enumOptions,
 			name: meta.name,
 			syntaxType,
 			description: node.description,
@@ -1045,15 +1574,23 @@ const typeGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1065,52 +1602,44 @@ const typeGenerator = defineGenerator({
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name: meta.name,
 				node,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: enumOptions,
 				resolver,
 				printer: schemaPrinter
 			})]
 		});
 	},
 	operation(node, ctx) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
-		const { adapter, config, resolver, root } = ctx;
-		const mode = ctx.getMode(output);
-		const params = ast.caseParams(node.parameters, paramsCasing);
-		const meta = { file: resolver.resolveFile({
+		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
+		const { config, resolver, root } = ctx;
+		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: group ?? void 0
 		}) };
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => ast.narrowSchema(s, ast.schemaTypes.enum) && s.name).map((s) => s.name));
-		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
-			return resolver.resolveTypeName(schemaName);
-		}
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
+		const importName = (schemaName) => resolveImportName({
+			schemaName,
+			enumOptions,
+			enumSchemaNames,
+			resolver
+		});
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
-			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolveImportName(schemaName),
-				path: resolver.resolveFile({
-					name: schemaName,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group
-				}).path
-			}));
+			const imports = resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0,
+				name: importName
+			});
 			const schemaPrinter = printerTs({
 				optionalType,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
+				enum: enumOptions,
 				name,
 				syntaxType,
 				description: schema.description,
@@ -1119,7 +1648,7 @@ const typeGenerator = defineGenerator({
 				enumSchemaNames,
 				nodes: printer?.nodes
 			});
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1131,17 +1660,50 @@ const typeGenerator = defineGenerator({
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name,
 				node: schema,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: enumOptions,
 				resolver,
 				printer: schemaPrinter
 			})] });
 		}
-		const paramTypes = params.map((param) => renderSchemaType({
-			schema: param.schema,
-			name: resolver.resolveParamName(node, param)
-		}));
+		/**
+		* Emits an individual type per content type plus a plain union alias under `baseName`. Shared by
+		* the request body and multi-content-type responses. The response record discriminates these
+		* variants by content type in {@link buildResponses}; the standalone alias stays a plain union so
+		* query hooks and `result.data` keep the bare body.
+		*/
+		function buildContentTypeVariants(entries, baseName, decorate) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.factory.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaType({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit
+			})), renderSchemaType({
+				schema: unionSchema,
+				name: baseName
+			})] });
+		}
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+		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;
@@ -1153,67 +1715,40 @@ const typeGenerator = defineGenerator({
 						...entry.schema,
 						description: node.requestBody.description ?? entry.schema.description
 					},
-					name: resolver.resolveDataName(node),
+					name: resolver.response.body(node),
 					keysToOmit: entry.keysToOmit
 				});
 			}
-			const dataName = resolver.resolveDataName(node);
-			const usedNames = /* @__PURE__ */ new Set();
-			const individualItems = requestBodyContent.filter((entry) => entry.schema).map((entry) => {
-				const baseSuffix = getContentTypeSuffix(entry.contentType);
-				let individualName = getPerContentTypeName(dataName, baseSuffix);
-				let counter = 2;
-				while (usedNames.has(individualName)) individualName = getPerContentTypeName(dataName, `${baseSuffix}${counter++}`);
-				usedNames.add(individualName);
-				return {
-					name: individualName,
-					rendered: renderSchemaType({
-						schema: {
-							...entry.schema,
-							description: node.requestBody.description ?? entry.schema.description
-						},
-						name: individualName,
-						keysToOmit: entry.keysToOmit
-					})
-				};
-			});
-			const unionType = renderSchemaType({
-				schema: ast.createSchema({
-					type: "union",
-					members: individualItems.map((item) => ast.createSchema({
-						type: "ref",
-						name: item.name
-					}))
-				}),
-				name: dataName
-			});
-			return /* @__PURE__ */ jsxs(Fragment, { children: [individualItems.map((item) => item.rendered), unionType] });
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}));
 		}
 		const requestType = buildRequestType();
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			schema: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
-		}));
-		const dataType = renderSchemaType({
-			schema: buildData({
-				...node,
-				parameters: params
-			}, { resolver }),
-			name: resolver.resolveRequestConfigName(node)
+		const responseTypes = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			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.response.status(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
+			});
+		});
+		const optionsType = renderSchemaType({
+			schema: buildOptionsSchema(node, resolver),
+			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
 			schema: buildResponses(node, { resolver }),
-			name: resolver.resolveResponsesName(node)
+			name: resolver.response.responses(node)
 		});
 		function buildResponseType() {
-			if (!node.responses.some((res) => res.schema)) return null;
-			const responseName = resolver.resolveResponseName(node);
-			const responsesWithSchema = node.responses.filter((res) => res.schema);
-			if (new Set(responsesWithSchema.flatMap((res) => res.schema ? adapter.getImports(res.schema, (schemaName) => ({
-				name: resolveImportName(schemaName),
-				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseName)) return null;
+			const hasSchema = (res) => (res.content ?? []).some((entry) => entry.schema);
+			if (!node.responses.some(hasSchema)) return null;
+			const responseName = resolver.response.response(node);
+			const responsesWithSchema = node.responses.filter(hasSchema);
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1227,19 +1762,27 @@ const typeGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
-				paramTypes,
+				paramGroupTypes,
 				responseTypes,
 				requestType,
-				dataType,
+				optionsType,
 				responsesType,
 				responseType
 			]
@@ -1249,101 +1792,84 @@ const typeGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverTs.ts
 /**
-* Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
-* helpers used by the plugin. Import this in other plugins to resolve the exact names and
-* paths that `plugin-ts` generates without hardcoding the conventions.
+* Default resolver used by `@kubb/plugin-ts`. Decides the names and file paths
+* for every generated TypeScript type. Import this in other plugins that need
+* to reference the exact names `plugin-ts` produces without duplicating the
+* casing/file-layout rules.
 *
-* The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
-* for identifiers/files and `pascalCase` for type names.
+* 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
+* @example Resolve a type and file name
 * ```ts
-* import { resolver } from '@kubb/plugin-ts'
+* import { resolverTs } from '@kubb/plugin-ts'
 *
-* resolver.default('list pets', 'type')              // → 'ListPets'
-* resolver.resolveName('list pets status 200')        // → 'ListPetsStatus200'
-* resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+* resolverTs.name('list pets')                     // 'ListPets'
+* resolverTs.response.status(node, 200)            // 'ListPetsStatus200'
 * ```
 */
-const resolverTs = defineResolver(() => {
-	return {
-		name: "default",
-		pluginName: "plugin-ts",
-		default(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
-		},
-		resolveTypeName(name) {
-			return pascalCase(name);
-		},
-		resolvePathName(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
-		},
-		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`);
-		},
-		resolveRequestConfigName(node) {
-			return this.resolveTypeName(`${node.operationId} RequestConfig`);
-		},
-		resolveResponsesName(node) {
-			return this.resolveTypeName(`${node.operationId} Responses`);
-		},
-		resolveResponseName(node) {
-			return this.resolveTypeName(`${node.operationId} Response`);
-		},
-		resolveEnumKeyName(node, enumTypeSuffix = "key") {
-			return `${this.resolveTypeName(node.name ?? "")}${enumTypeSuffix}`;
-		},
-		resolvePathParamsName(node, param) {
-			return this.resolveParamName(node, param);
-		},
-		resolveQueryParamsName(node, param) {
-			return this.resolveParamName(node, param);
-		},
-		resolveHeaderParamsName(node, param) {
-			return this.resolveParamName(node, param);
+const resolverTs = createResolver({
+	pluginName: "plugin-ts",
+	name(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	file: createCasedFile(pascalCase),
+	param: createOperationParamResolver(),
+	response: {
+		...createOperationResponseResolver(),
+		options(node) {
+			return this.name(`${node.operationId} Options`);
 		}
-	};
+	},
+	enum: { keyName(node, enumTypeSuffix = "key") {
+		return `${this.name(node.name ?? "")}${enumTypeSuffix}`;
+	} }
 });
 //#endregion
 //#region src/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-ts`, used to identify the plugin in driver lookups and warnings.
+* Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and
+* cross-plugin dependency references.
 */
 const pluginTsName = "plugin-ts";
 /**
-* The `@kubb/plugin-ts` plugin factory.
-*
-* Generates TypeScript type declarations from an OpenAPI/AST `RootNode`.
-* Walks schemas and operations, delegates rendering to the active generators,
-* and writes barrel files based on `output.barrelType`.
+* Generates TypeScript `type` aliases and `interface` declarations from an
+* OpenAPI spec. The foundation that every other Kubb plugin builds on:
+* clients, query hooks, mocks, and validators all reference the names this
+* plugin produces.
 *
 * @example
 * ```ts
-* import pluginTs from '@kubb/plugin-ts'
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
 *
 * export default defineConfig({
-*   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs({
+*       output: { path: './types' },
+*       enum: { type: 'asConst' },
+*       optionalType: 'questionTokenAndUndefined',
+*     }),
+*   ],
 * })
 * ```
 */
 const pluginTs = definePlugin((options) => {
 	const { output = {
 		path: "types",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], enum: enumOptions = {}, optionalType = "questionToken", arrayType = "array", syntaxType = "type", printer, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
+	const resolvedEnum = {
+		type: enumOptions.type ?? "asConst",
+		constCasing: enumOptions.constCasing ?? "camelCase",
+		typeSuffix: enumOptions.typeSuffix ?? "Key",
+		keyCasing: enumOptions.keyCasing ?? "none"
+	};
 	return {
 		name: pluginTsName,
 		options,
@@ -1356,56 +1882,236 @@ const pluginTs = definePlugin((options) => {
 				optionalType,
 				group: groupConfig,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: resolvedEnum,
 				syntaxType,
-				paramsCasing,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverTs,
-				...userResolver
-			} : resolverTs);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			ctx.setResolver(userResolver ? Resolver.merge(resolverTs, userResolver) : resolverTs);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(typeGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });
 //#endregion
+//#region src/printers/functionParams.ts
+/**
+* Narrows a {@link TypeExpression} to a {@link TypeLiteralNode}.
+*/
+function isTypeLiteral(type) {
+	return typeof type !== "string" && type.kind === "TypeLiteral";
+}
+/**
+* Narrows a {@link TypeExpression} to an {@link IndexedAccessTypeNode}.
+*/
+function isIndexedAccessType(type) {
+	return typeof type !== "string" && type.kind === "IndexedAccessType";
+}
+/**
+* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+*
+* @example
+* ```ts
+* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+* // { petId: string }
+* ```
+*/
+function createTypeLiteral(props) {
+	return {
+		kind: "TypeLiteral",
+		...props
+	};
+}
+/**
+* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+*
+* @example
+* ```ts
+* createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+* // DeletePetPathParams['petId']
+* ```
+*/
+function createIndexedAccessType(props) {
+	return {
+		kind: "IndexedAccessType",
+		...props
+	};
+}
+/**
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+*
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
+*/
+function createObjectBindingPattern(props) {
+	return {
+		kind: "ObjectBindingPattern",
+		...props
+	};
+}
+/**
+* Creates a {@link FunctionParameterNode}. `optional` defaults to `false`.
+* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+* paired with a {@link TypeLiteralNode} type.
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Destructured group
+* ```ts
+* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+* // → { id, name }: { id: string; name?: string } = {}
+* ```
+*/
+function createFunctionParameter(input) {
+	if ("properties" in input) return {
+		kind: "FunctionParameter",
+		name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
+		type: createTypeLiteral({ members: input.properties.map((p) => ({
+			name: p.name,
+			type: p.type,
+			optional: p.optional ?? false
+		})) }),
+		optional: input.optional ?? false,
+		...input.default !== void 0 ? { default: input.default } : {}
+	};
+	return {
+		kind: "FunctionParameter",
+		optional: false,
+		...input
+	};
+}
+/**
+* Creates a {@link FunctionParametersNode} from an ordered list of parameters.
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { params: [] }
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return {
+		kind: "FunctionParameters",
+		params: [],
+		...props
+	};
+}
+//#endregion
 //#region src/printers/functionPrinter.ts
-const kindToHandlerKey = {
-	FunctionParameter: "functionParameter",
-	ParameterGroup: "parameterGroup",
-	FunctionParameters: "functionParameters",
-	ParamsType: "paramsType"
-};
 /**
-* Creates a function-parameter printer factory.
+* Renders a {@link TypeExpression} to its TypeScript source.
+*
+* - a `string` is a type reference, returned as-is
+* - an `IndexedAccessType` becomes `objectType['indexType']`
+* - a `TypeLiteral` becomes `{ key: Type; key?: Type }`
 *
-* Uses `createPrinterFactory` and dispatches handlers by `node.kind`
-* (for function nodes) rather than by `node.type` (for schema nodes).
+* `transformType` is applied once to the fully rendered type, matching how the
+* printer wrapped reference types before the `ts.factory` model.
+*/
+function renderType(type, transformType) {
+	const rendered = renderTypeExpression(type);
+	return transformType ? transformType(rendered) : rendered;
+}
+/**
+* Renders an object-type key, quoting it as a string literal when it is not a valid
+* identifier so `{ 'content-type': string }` stays valid TypeScript.
 */
-const defineFunctionPrinter = ast.createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+function renderKey(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function renderTypeExpression(type) {
+	if (typeof type === "string") return type;
+	if (isIndexedAccessType(type)) return `${type.target}['${type.key}']`;
+	return `{ ${type.members.map((member) => {
+		const value = renderTypeExpression(member.type);
+		return member.optional ? `${renderKey(member.name)}?: ${value}` : `${renderKey(member.name)}: ${value}`;
+	}).join("; ")} }`;
+}
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && isTypeLiteral(param.type) ? param.type.members : [];
+}
 function rank(param) {
-	if (param.kind === "ParameterGroup") {
-		if (param.default) return PARAM_RANK.withDefault;
-		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? PARAM_RANK.optional : PARAM_RANK.required;
-	}
 	if (param.rest) return PARAM_RANK.rest;
 	if (param.default) return PARAM_RANK.withDefault;
+	const members = groupMembers(param);
+	if (members) return members.every((m) => m.optional) ? PARAM_RANK.optional : PARAM_RANK.required;
 	return param.optional ? PARAM_RANK.optional : PARAM_RANK.required;
 }
 function sortParams(params) {
-	return [...params].sort((a, b) => rank(a) - rank(b));
+	return params.toSorted((a, b) => rank(a) - rank(b));
+}
+function sortedGroupMembers(name, type) {
+	const members = type && isTypeLiteral(type) ? type.members : [];
+	const memberRank = (optional) => optional ? PARAM_RANK.optional : PARAM_RANK.required;
+	return name.elements.map((element, index) => ({
+		name: element.name,
+		propertyName: element.propertyName,
+		type: members[index]?.type,
+		optional: members[index]?.optional
+	})).toSorted((a, b) => memberRank(a.optional) - memberRank(b.optional));
+}
+/**
+* Renders one binding element: the local name, prefixed with its source key when the
+* binding renames the property, as in `{ petId: id }`.
+*/
+function renderBindingMember(member, transformName) {
+	const local = transformName ? transformName(member.name) : member.name;
+	return member.propertyName ? `${member.propertyName}: ${local}` : local;
 }
-function sortChildParams(params) {
-	return [...params].sort((a, b) => rank(a) - rank(b));
+/**
+* Renders the type annotation of a destructured group. An inline object type is
+* rendered from the already-sorted members so its key order matches the binding;
+* a reference type is rendered as-is.
+*/
+function renderGroupType(type, sorted, transformType) {
+	if (!type) return void 0;
+	if (!isTypeLiteral(type)) return renderType(type);
+	const typed = sorted.filter((member) => member.type !== void 0);
+	if (!typed.length) return void 0;
+	return `{ ${typed.map((member) => {
+		const key = renderKey(member.propertyName ?? member.name);
+		const value = renderType(member.type, transformType);
+		return member.optional ? `${key}?: ${value}` : `${key}: ${value}`;
+	}).join("; ")} }`;
+}
+function printParameter(node, options) {
+	const { mode, transformName, transformType } = options;
+	const bindingName = node.name;
+	if (mode === "call") {
+		if (typeof bindingName !== "string") return `{ ${sortedGroupMembers(bindingName, node.type).map((member) => renderBindingMember(member)).join(", ")} }`;
+		const name = transformName ? transformName(bindingName) : bindingName;
+		return node.rest ? `...${name}` : name;
+	}
+	if (typeof bindingName !== "string") {
+		const sorted = sortedGroupMembers(bindingName, node.type);
+		const binding = `{ ${sorted.map((member) => renderBindingMember(member, transformName)).join(", ")} }`;
+		const allOptional = sorted.every((member) => member.optional);
+		const type = renderGroupType(node.type, sorted, transformType);
+		if (type) {
+			if (allOptional) return `${binding}: ${type} = ${node.default ?? "{}"}`;
+			return node.default ? `${binding}: ${type} = ${node.default}` : `${binding}: ${type}`;
+		}
+		return node.default ? `${binding} = ${node.default}` : binding;
+	}
+	const name = transformName ? transformName(bindingName) : bindingName;
+	const type = node.type ? renderType(node.type, transformType) : void 0;
+	if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
+	if (type) {
+		if (node.optional) return `${name}?: ${type}`;
+		return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
+	}
+	return node.default ? `${name} = ${node.default}` : name;
 }
 /**
-* Default function-signature printer.
-* Covers the four standard output modes used across Kubb plugins.
+* Default function-signature printer. Renders a parameter list in one of two modes:
+* `declaration` for the function signature and `call` for the call arguments.
 *
 * @example
 * ```ts
@@ -1421,68 +2127,195 @@ function sortChildParams(params) {
 * printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-const functionPrinter = defineFunctionPrinter((options) => ({
-	name: "functionParameters",
-	options,
-	nodes: {
-		paramsType(node) {
-			if (node.kind !== "ParamsType") return null;
-			if (node.variant === "member") return `${node.base}['${node.key}']`;
-			if (node.variant === "struct") return `{ ${node.properties.map((p) => {
-				const typeStr = this.transform(p.type);
-				const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-				return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-			}).join("; ")} }`;
-			if (node.variant === "reference") return node.name;
-			return null;
-		},
-		functionParameter(node) {
-			const { mode, transformName, transformType } = this.options;
-			const name = transformName ? transformName(node.name) : node.name;
-			const rawType = node.type ? this.transform(node.type) : void 0;
-			const type = rawType != null && transformType ? transformType(rawType) : rawType;
-			if (mode === "keys" || mode === "values") return node.rest ? `...${name}` : name;
-			if (mode === "call") return node.rest ? `...${name}` : name;
-			if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
-			if (type) {
-				if (node.optional) return `${name}?: ${type}`;
-				return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
-			}
-			return node.default ? `${name} = ${node.default}` : name;
-		},
-		parameterGroup(node) {
-			const { mode, transformName, transformType } = this.options;
-			const sorted = sortChildParams(node.properties);
-			const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== void 0);
-			if (node.inline) return sorted.map((p) => this.transform(p)).filter(Boolean).join(", ");
-			if (mode === "keys" || mode === "values") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
-			if (mode === "call") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
-			const names = sorted.map((p) => {
-				return transformName ? transformName(p.name) : p.name;
-			});
-			const nameStr = names.length ? `{ ${names.join(", ")} }` : void 0;
-			if (!nameStr) return null;
-			let typeAnnotation = node.type ? this.transform(node.type) ?? void 0 : void 0;
-			if (!typeAnnotation) {
-				const typeParts = sorted.filter((p) => p.type).map((p) => {
-					const rawT = p.type ? this.transform(p.type) : void 0;
-					const t = rawT != null && transformType ? transformType(rawT) : rawT;
-					return p.optional || p.default !== void 0 ? `${p.name}?: ${t}` : `${p.name}: ${t}`;
-				});
-				typeAnnotation = typeParts.length ? `{ ${typeParts.join("; ")} }` : void 0;
-			}
-			if (typeAnnotation) {
-				if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? "{}"}`;
-				return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`;
-			}
-			return node.default ? `${nameStr} = ${node.default}` : nameStr;
-		},
-		functionParameters(node) {
-			return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+function functionPrinter(options) {
+	return {
+		name: "functionParameters",
+		options,
+		print(node) {
+			return sortParams(node.params).map((p) => printParameter(p, options)).filter(Boolean).join(", ");
+		}
+	};
+}
+//#endregion
+//#region src/printers/operationParams.ts
+/**
+* Resolves the {@link TypeExpression} for an individual parameter.
+*
+* Without a resolver, it falls back to the schema primitive (a plain type-name string). When the
+* parameter belongs to a named group, it emits an `IndexedAccessType` like `GroupParams['petId']`,
+* otherwise the resolved individual name.
+*/
+function resolveParamType({ node, param, resolver }) {
+	if (!resolver) return param.schema.primitive ?? "unknown";
+	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.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({
+		target: groupName,
+		key: param.name
+	});
+	return individualName;
+}
+/**
+* Derives a {@link ParamGroupType} for a query or header group from the resolver.
+*
+* Returns `null` when there is no resolver, no params, or the group name equals the
+* individual param name (so there is no real group to emit).
+*/
+function resolveGroupType({ node, params, group, resolver }) {
+	if (!resolver || !params.length) return null;
+	const firstParam = params[0];
+	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)
+	};
+}
+/**
+* Converts an `OperationNode` into function parameters for code generation.
+*
+* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
+	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+	const toProperty = (param) => ({
+		name: param.name,
+		type: wrapTypeExpression(resolveParamType({
+			node,
+			param,
+			resolver
+		})),
+		optional: !param.required
+	});
+	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.response.body(node) ?? "unknown") : void 0;
+	const bodyProperty = bodyType ? [{
+		name: dataName,
+		type: bodyType,
+		optional: !(node.requestBody?.required ?? false)
+	}] : [];
+	const trailingGroups = [{
+		name: paramsName,
+		node,
+		params: queryParams,
+		groupType: resolveGroupType({
+			node,
+			params: queryParams,
+			group: "query",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}, {
+		name: headersName,
+		node,
+		params: headerParams,
+		groupType: resolveGroupType({
+			node,
+			params: headerParams,
+			group: "header",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}];
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map(toProperty),
+			...bodyProperty,
+			...trailingGroups.flatMap(buildGroupProperty)
+		];
+		if (children.length) params.push(createFunctionParameter({
+			properties: children,
+			default: emptyObjectDefault(children)
+		}));
+	} else {
+		if (pathParamsType === "inlineSpread" && pathParams.length) {
+			const spreadType = resolver?.param.path(node, pathParams[0]);
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
+		else if (pathParams.length) {
+			const pathChildren = pathParams.map(toProperty);
+			params.push(createFunctionParameter({
+				properties: pathChildren,
+				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
+			}));
 		}
+		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
+		params.push(...trailingGroups.flatMap(buildGroupParam));
 	}
-}));
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds the property descriptor for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
+*/
+function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [{
+		name,
+		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
+		optional: groupType.optional
+	}];
+	if (params.length) return [{
+		name,
+		type: buildTypeLiteral({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	}];
+	return [];
+}
+/**
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
+*/
+function buildGroupParam(args) {
+	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
+}
+/**
+* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+*/
+function buildTypeLiteral({ node, params, resolver }) {
+	return createTypeLiteral({ members: params.map((p) => ({
+		name: p.name,
+		type: resolveParamType({
+			node,
+			param: p,
+			resolver
+		}),
+		optional: !p.required
+	})) });
+}
 //#endregion
-export { Enum, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, 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