@kubb/plugin-ts 5.0.0-beta.4 → 5.0.0-beta.56

package/dist/index.cjs

@@ -5,6 +5,10 @@ Object.defineProperties(exports, {
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
@@ -24,10 +28,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_parser_ts = require("@kubb/parser-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_core = require("@kubb/core");
-let remeda = require("remeda");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
@@ -42,58 +46,41 @@ let _kubb_renderer_jsx_jsx_runtime = require("@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("_");
@@ -101,8 +88,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, {
@@ -111,60 +98,152 @@ function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	}).toUpperCase();
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
+* 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
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
-*/
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
 /**
-* Escapes characters that are not allowed inside JS string literals.
-* Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).
-*
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = 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
-* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
 * ```
 */
-function jsStringEscape(input) {
-	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-		switch (character) {
-			case "\"":
-			case "'":
-			case "\\": return `\\${character}`;
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "\u2028": return "\\u2028";
-			case "\u2029": return "\\u2029";
-			default: return "";
-		}
-	});
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-//#endregion
-//#region ../../internals/utils/src/object.ts
 /**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+* 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
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
 */
-function stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(trimQuotes(value.toString()));
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
 }
 //#endregion
 //#region src/constants.ts
@@ -177,26 +256,24 @@ const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined
 */
 const OPTIONAL_ADDS_QUESTION_TOKEN = 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 = 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([
 	"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([
 	"asConst",
-	"asPascalConst",
 	"literal",
 	void 0
 ]);
@@ -212,6 +289,9 @@ const PARAM_RANK = {
 //#endregion
 //#region src/factory.ts
 const { SyntaxKind, factory } = typescript.default;
+function isNumber(value) {
+	return typeof value === "number" && !Number.isNaN(value);
+}
 /**
 * TypeScript AST modifiers for common keywords (async, export, const, static).
 */
@@ -229,10 +309,19 @@ const syntaxKind = {
 	literalType: SyntaxKind.LiteralType,
 	stringLiteral: SyntaxKind.StringLiteral
 };
+function isNonNullable$1(value) {
+	return value !== null && value !== void 0;
+}
+__name(isNonNullable$1, "isNonNullable");
 function isValidIdentifier(str) {
 	if (!str.length || str.trim() !== str) return false;
-	const node = typescript.default.parseIsolatedEntityName(str, typescript.default.ScriptTarget.Latest);
-	return !!node && node.kind === typescript.default.SyntaxKind.Identifier && typescript.default.identifierToKeywordKind(node.kind) === void 0;
+	let ch = str.codePointAt(0);
+	if (!typescript.default.isIdentifierStart(ch, typescript.default.ScriptTarget.Latest)) return false;
+	for (let i = ch > 65535 ? 2 : 1; i < str.length; i += ch > 65535 ? 2 : 1) {
+		ch = str.codePointAt(i);
+		if (!typescript.default.isIdentifierPart(ch, typescript.default.ScriptTarget.Latest)) return false;
+	}
+	return true;
 }
 function propertyName(name) {
 	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -298,7 +387,7 @@ function createUnionDeclaration({ nodes, withParentheses }) {
 * Supports optional markers, readonly modifiers, and type annotations.
 */
 function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
-	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.default.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken), type);
+	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.default.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
 }
 /**
 * Creates a function parameter declaration with optional markers, rest parameters, and type annotations.
@@ -390,19 +479,19 @@ function applyEnumKeyCasing(key, casing = "none") {
 */
 function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCasing = "none" }) {
 	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
-		if ((0, remeda.isNumber)(value)) {
+		if (isNumber(value)) {
 			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))));
 			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()));
-	}).filter(Boolean)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter(Boolean), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+	}).filter((node) => node !== void 0)))];
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if (Number.parseInt(value.toString(), 10) === value && (0, remeda.isNumber)(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		if (Number.parseInt(value.toString(), 10) === value && isNumber(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
-		if ((0, remeda.isNumber)(Number.parseInt(key.toString(), 10))) {
+		if (isNumber(Number.parseInt(key.toString(), 10))) {
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
 			return factory.createEnumMember(propertyName(casingKey), initializer);
 		}
@@ -410,19 +499,19 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
 			return factory.createEnumMember(propertyName(casingKey), initializer);
 		}
-	}).filter(Boolean))];
+	}).filter((member) => member !== void 0))];
 	const identifierName = name;
 	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(typescript.default.SyntaxKind.NeverKeyword))];
 	return [factory.createVariableStatement([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
-		if ((0, remeda.isNumber)(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 		else initializer = factory.createNumericLiteral(value);
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
 		if (key) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
 			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
 		}
-	}).filter(Boolean), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.default.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.default.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
 }
 /**
 * Creates a TypeScript `Omit<T, Keys>` type reference node.
@@ -504,12 +593,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.
 */
@@ -534,8 +621,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).
 */
@@ -562,14 +647,14 @@ function dateOrStringNode(node) {
 * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
 */
 function buildMemberNodes(members, print) {
-	return (members ?? []).map(print).filter(Boolean);
+	return (members ?? []).map(print).filter(isNonNullable$1);
 }
 /**
 * Builds a TypeScript tuple type node from an array schema's `items`,
 * applying min/max slice and optional/rest element rules.
 */
 function buildTupleNode(node, print) {
-	let items = (node.items ?? []).map(print).filter(Boolean);
+	let items = (node.items ?? []).map(print).filter(isNonNullable$1);
 	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
 	const { min, max } = node;
 	if (max !== void 0) {
@@ -616,58 +701,61 @@ 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 }) {
+function getEnumNames({ node, enum: enumOptions, resolver }) {
 	const resolved = resolver.default(node.name, "type");
 	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.resolveEnumKeyName(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) => [(0, _kubb_ast_utils.trimQuotes)(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [(0, _kubb_ast_utils.trimQuotes)(v.toString()), v]) ?? [],
+		type: enumOptions.type,
+		enumKeyCasing: enumOptions.keyCasing
 	});
+	const namesMerge = !!nameNode && enumName === typeName;
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name: enumName,
 		isExportable: true,
 		isIndexable: true,
 		isTypeOnly: false,
-		children: (0, _kubb_parser_ts.safePrint)(nameNode)
+		children: _kubb_parser_ts.parserTs.print(nameNode)
 	}), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name: typeName,
-		isIndexable: true,
-		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
-		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-		children: (0, _kubb_parser_ts.safePrint)(typeNode)
+		isIndexable: !namesMerge,
+		isExportable: !namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type),
+		children: _kubb_parser_ts.parserTs.print(typeNode)
 	})] });
 }
 //#endregion
 //#region src/components/Type.tsx
-function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
 	const enumSchemaNodes = _kubb_core.ast.collect(node, { schema(n) {
 		const enumNode = _kubb_core.ast.narrowSchema(n, _kubb_core.ast.schemaTypes.enum);
 		if (enumNode?.name) return enumNode;
@@ -679,19 +767,16 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 			node,
 			...getEnumNames({
 				node,
-				enumType,
-				enumTypeSuffix,
+				enum: enumOptions,
 				resolver
 			})
 		};
 	});
-	const shouldExportEnums = enumType !== "inlineLiteral";
-	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Enum, {
 		node,
-		enumType,
-		enumTypeSuffix,
-		enumKeyCasing,
+		enum: enumOptions,
 		resolver
 	}, node.name)), shouldExportType && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
@@ -702,6 +787,96 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 	})] });
 }
 //#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 {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+function getOperationParameters(node, options = {}) {
+	const params = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
+	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")
+	};
+}
+//#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 src/utils.ts
 /**
 * Collects JSDoc annotation strings for a schema node.
@@ -713,15 +888,18 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 function buildPropertyJSDocComments(schema) {
 	const meta = _kubb_core.ast.syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
+	const hasDescription = meta && "description" in meta && meta.description;
+	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
 	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
+		hasDescription ? `@description ${(0, _kubb_ast_utils.jsStringEscape)(meta.description)}` : null,
+		...formatComment,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? (0, _kubb_ast_utils.stringify)(meta.default) : meta.default}` : null,
+		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : null,
+		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
 function buildParams(node, { params, resolver }) {
@@ -738,9 +916,7 @@ function buildParams(node, { params, resolver }) {
 	});
 }
 function buildData(node, { resolver }) {
-	const pathParams = node.parameters.filter((p) => p.in === "path");
-	const queryParams = node.parameters.filter((p) => p.in === "query");
-	const headerParams = node.parameters.filter((p) => p.in === "header");
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 	return _kubb_core.ast.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
@@ -822,7 +998,7 @@ function buildResponses(node, { 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 _kubb_core.ast.createSchema({
 		type: "union",
@@ -834,6 +1010,9 @@ function buildResponseUnion(node, { resolver }) {
 }
 //#endregion
 //#region src/printers/printerTs.ts
+function isNonNullable(value) {
+	return value !== null && value !== void 0;
+}
 /**
 * TypeScript type printer built with `definePrinter`.
 *
@@ -847,13 +1026,13 @@ function buildResponseUnion(node, { resolver }) {
 *
 * @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
 * ```
 */
@@ -886,17 +1065,17 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 			date: dateOrStringNode,
 			time: dateOrStringNode,
 			ref(node) {
-				if (!node.name) return;
-				const refName = node.ref ? _kubb_core.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 = node.ref ? (0, _kubb_ast_utils.extractRefName)(node.ref) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, 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) return createUnionDeclaration({
 					withParentheses: true,
-					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+					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);
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
 			},
 			union(node) {
 				const members = node.members ?? [];
@@ -912,7 +1091,7 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 							withParentheses: true
 						});
 						return this.transform(m);
-					}).filter(Boolean)
+					}).filter(isNonNullable)
 				}) ?? void 0;
 				return createUnionDeclaration({
 					withParentheses: true,
@@ -923,16 +1102,16 @@ const printerTs = _kubb_core.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(Boolean),
+					nodes: (node.items ?? []).map((item) => this.transform(item)).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;
@@ -959,48 +1138,55 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 		},
 		print(node) {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
-			let base = this.transform(node);
-			if (!base) return null;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
 			const meta = _kubb_core.ast.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 (0, _kubb_parser_ts.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 _kubb_parser_ts.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 (0, _kubb_parser_ts.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 _kubb_parser_ts.parserTs.print(typeNode);
 		}
 	};
 });
 //#endregion
 //#region src/generators/typeGenerator.tsx
+/**
+* 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 = (0, _kubb_core.defineGenerator)({
 	name: "typescript",
 	renderer: _kubb_renderer_jsx.jsxRenderer,
 	schema(node, ctx) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
+		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
 		if (!node.name) return;
-		const mode = ctx.getMode(output);
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => _kubb_core.ast.narrowSchema(s, _kubb_core.ast.schemaTypes.enum) && s.name).map((s) => s.name));
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
 			return resolver.resolveTypeName(schemaName);
 		}
 		const imports = adapter.getImports(node, (schemaName) => ({
@@ -1011,26 +1197,25 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
 		}));
 		const isEnumSchema = !!_kubb_core.ast.narrowSchema(node, _kubb_core.ast.schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
 				name: node.name,
 				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,
@@ -1042,15 +1227,23 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			children: [imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1062,18 +1255,15 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			].join("-"))), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.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 { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
-		const mode = ctx.getMode(output);
 		const params = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
@@ -1083,11 +1273,11 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		}) };
-		const enumSchemaNames = new Set((adapter.inputNode?.schemas ?? []).filter((s) => _kubb_core.ast.narrowSchema(s, _kubb_core.ast.schemaTypes.enum) && s.name).map((s) => s.name));
+		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
 			return resolver.resolveTypeName(schemaName);
 		}
 		function renderSchemaType({ schema, name, keysToOmit }) {
@@ -1100,14 +1290,13 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				}).path
 			}));
 			const schemaPrinter = printerTs({
 				optionalType,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
+				enum: enumOptions,
 				name,
 				syntaxType,
 				description: schema.description,
@@ -1116,7 +1305,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				enumSchemaNames,
 				nodes: printer?.nodes
 			});
-			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1128,30 +1317,68 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			].join("-"))), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Type, {
 				name,
 				node: schema,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: enumOptions,
 				resolver,
 				printer: schemaPrinter
 			})] });
 		}
+		/**
+		* Emits an individual type per content type plus a union alias under `baseName`.
+		* Shared by the request body and multi-content-type responses.
+		*/
+		function buildContentTypeVariants(entries, baseName, decorate) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = _kubb_core.ast.createSchema({
+				type: "union",
+				members: variants.map((variant) => _kubb_core.ast.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [variants.map((variant) => renderSchemaType({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit
+			})), renderSchemaType({
+				schema: unionSchema,
+				name: baseName
+			})] });
+		}
 		const paramTypes = params.map((param) => renderSchemaType({
 			schema: param.schema,
 			name: resolver.resolveParamName(node, param)
 		}));
-		const requestType = node.requestBody?.content?.[0]?.schema ? renderSchemaType({
-			schema: {
-				...node.requestBody.content[0].schema,
-				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
-			},
-			name: resolver.resolveDataName(node),
-			keysToOmit: node.requestBody.content[0].keysToOmit
-		}) : null;
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			schema: res.schema,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
-		}));
+		const requestBodyContent = node.requestBody?.content ?? [];
+		function buildRequestType() {
+			if (requestBodyContent.length === 0) return null;
+			if (requestBodyContent.length === 1) {
+				const entry = requestBodyContent[0];
+				if (!entry.schema) return null;
+				return renderSchemaType({
+					schema: {
+						...entry.schema,
+						description: node.requestBody.description ?? entry.schema.description
+					},
+					name: resolver.resolveDataName(node),
+					keysToOmit: entry.keysToOmit
+				});
+			}
+			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}));
+		}
+		const requestType = buildRequestType();
+		const responseTypes = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaType({
+				schema: primary?.schema ?? null,
+				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
+			});
+		});
 		const dataType = renderSchemaType({
 			schema: buildData({
 				...node,
@@ -1163,14 +1390,15 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			schema: buildResponses(node, { resolver }),
 			name: resolver.resolveResponsesName(node)
 		});
-		const responseType = (() => {
-			if (!node.responses.some((res) => res.schema)) return null;
+		function buildResponseType() {
+			const hasSchema = (res) => (res.content ?? []).some((entry) => entry.schema);
+			if (!node.responses.some(hasSchema)) 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) => ({
+			const responsesWithSchema = node.responses.filter(hasSchema);
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
 				name: resolveImportName(schemaName),
 				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseName)) return null;
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1178,18 +1406,27 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				},
 				name: responseName
 			});
-		})();
+		}
+		const responseType = buildResponseType();
 		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				paramTypes,
@@ -1205,101 +1442,113 @@ const typeGenerator = (0, _kubb_core.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` method is supplied by `defineResolver`. It uses PascalCase for
+* type names and PascalCase file paths (dotted names become `/`-joined) for files.
 *
-* @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.default('list pets', 'type')        // 'ListPets'
+* resolverTs.resolvePathName('list pets', 'file') // 'ListPets'
+* resolverTs.resolveResponseStatusName(node, 200) // 'ListPetsStatus200'
 * ```
 */
-const resolverTs = (0, _kubb_core.defineResolver)((ctx) => {
+const resolverTs = (0, _kubb_core.defineResolver)(() => {
 	return {
 		name: "default",
 		pluginName: "plugin-ts",
 		default(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
+			if (type === "file") return toFilePath(name, pascalCase);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolveTypeName(name) {
-			return pascalCase(name);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolvePathName(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
+			if (type === "file") return toFilePath(name, pascalCase);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolveParamName(node, param) {
-			return ctx.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`);
+			return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`);
 		},
 		resolveResponseStatusName(node, statusCode) {
-			return ctx.resolveTypeName(`${node.operationId} Status ${statusCode}`);
+			return this.resolveTypeName(`${node.operationId} Status ${statusCode}`);
 		},
 		resolveDataName(node) {
-			return ctx.resolveTypeName(`${node.operationId} Data`);
+			return this.resolveTypeName(`${node.operationId} Data`);
 		},
 		resolveRequestConfigName(node) {
-			return ctx.resolveTypeName(`${node.operationId} RequestConfig`);
+			return this.resolveTypeName(`${node.operationId} RequestConfig`);
 		},
 		resolveResponsesName(node) {
-			return ctx.resolveTypeName(`${node.operationId} Responses`);
+			return this.resolveTypeName(`${node.operationId} Responses`);
 		},
 		resolveResponseName(node) {
-			return ctx.resolveTypeName(`${node.operationId} Response`);
+			return this.resolveTypeName(`${node.operationId} Response`);
 		},
 		resolveEnumKeyName(node, enumTypeSuffix = "key") {
-			return `${ctx.resolveTypeName(node.name ?? "")}${enumTypeSuffix}`;
+			return `${this.resolveTypeName(node.name ?? "")}${enumTypeSuffix}`;
 		},
 		resolvePathParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveQueryParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		},
 		resolveHeaderParamsName(node, param) {
-			return ctx.resolveParamName(node, param);
+			return this.resolveParamName(node, param);
 		}
 	};
 });
 //#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'
+* import { pluginTs } from '@kubb/plugin-ts'
 *
 * export default defineConfig({
-*   plugins: [pluginTs({ output: { path: 'types' }, enumType: 'asConst' })],
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs({
+*       output: { path: './types' },
+*       enum: { type: 'asConst' },
+*       optionalType: 'questionTokenAndUndefined',
+*     }),
+*   ],
 * })
 * ```
 */
 const pluginTs = (0, _kubb_core.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", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = 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,
@@ -1312,9 +1561,7 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 				optionalType,
 				group: groupConfig,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: resolvedEnum,
 				syntaxType,
 				paramsCasing,
 				printer
@@ -1354,10 +1601,10 @@ function rank(param) {
 	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 sortChildParams(params) {
-	return [...params].sort((a, b) => rank(a) - rank(b));
+	return params.toSorted((a, b) => rank(a) - rank(b));
 }
 /**
 * Default function-signature printer.