@kubb/plugin-ts 5.0.0-beta.3 → 5.0.0-beta.30

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;
@@ -167,6 +171,129 @@ function stringify(value) {
 	return JSON.stringify(trimQuotes(value.toString()));
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* 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
+* 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 /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(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}`;
+}
+//#endregion
 //#region src/constants.ts
 /**
 * `optionalType` values that cause a property's type to include `| undefined`.
@@ -229,6 +356,10 @@ 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);
@@ -298,7 +429,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.
@@ -396,8 +527,8 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		}
 		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)));
 		else initializer = factory.createNumericLiteral(value);
@@ -410,7 +541,7 @@ 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]) => {
@@ -422,7 +553,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 			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.
@@ -562,14 +693,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) {
@@ -656,13 +787,13 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
 		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)
+		children: _kubb_parser_ts.parserTs.print(typeNode)
 	})] });
 }
 //#endregion
@@ -702,6 +833,17 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 	})] });
 }
 //#endregion
+//#region ../../internals/shared/src/operation.ts
+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 src/utils.ts
 /**
 * Collects JSDoc annotation strings for a schema node.
@@ -713,15 +855,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 ${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" ? 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 +883,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 +965,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?.[0]?.schema);
 	if (responsesWithSchema.length === 0) return null;
 	return _kubb_core.ast.createSchema({
 		type: "union",
@@ -834,6 +977,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`.
 *
@@ -886,7 +1032,7 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 			date: dateOrStringNode,
 			time: dateOrStringNode,
 			ref(node) {
-				if (!node.name) return;
+				if (!node.name) return null;
 				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);
 			},
@@ -894,7 +1040,7 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
 				if (this.options.enumType === "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);
 			},
@@ -912,7 +1058,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 +1069,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,46 +1105,67 @@ 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
+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;
+}
+/**
+* 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,
+	renderer: _kubb_renderer_jsx.jsxRendererSync,
 	schema(node, ctx) {
 		const { enumType, enumTypeSuffix, enumKeyCasing, 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);
 			return resolver.resolveTypeName(schemaName);
@@ -1011,7 +1178,7 @@ 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);
@@ -1023,7 +1190,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			})
 		};
 		const schemaPrinter = printerTs({
@@ -1042,13 +1209,21 @@ 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, {
 				root: meta.file.path,
@@ -1083,9 +1258,9 @@ 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);
 			return resolver.resolveTypeName(schemaName);
@@ -1100,7 +1275,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				}).path
 			}));
 			const schemaPrinter = printerTs({
@@ -1139,18 +1314,58 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 			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 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
+				});
+			}
+			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: _kubb_core.ast.createSchema({
+					type: "union",
+					members: individualItems.map((item) => _kubb_core.ast.createSchema({
+						type: "ref",
+						name: item.name
+					}))
+				}),
+				name: dataName
+			});
+			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [individualItems.map((item) => item.rendered), unionType] });
+		}
+		const requestType = buildRequestType();
 		const responseTypes = node.responses.map((res) => renderSchemaType({
-			schema: res.schema,
+			schema: res.content?.[0]?.schema ?? null,
 			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.keysToOmit
+			keysToOmit: res.content?.[0]?.keysToOmit
 		}));
 		const dataType = renderSchemaType({
 			schema: buildData({
@@ -1163,11 +1378,11 @@ 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() {
+			if (!node.responses.some((res) => res.content?.[0]?.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) => ({
+			const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema);
+			if (new Set(responsesWithSchema.flatMap((res) => res.content?.[0]?.schema ? adapter.getImports(res.content[0].schema, (schemaName) => ({
 				name: resolveImportName(schemaName),
 				path: ""
 			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseName)) return null;
@@ -1178,18 +1393,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,86 +1429,98 @@ 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-with-isFile 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" });
+			const resolved = pascalCase(name, { isFile: type === "file" });
+			return type === "file" ? resolved : ensureValidVarName(resolved);
 		},
 		resolveTypeName(name) {
-			return pascalCase(name);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolvePathName(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
+			const resolved = pascalCase(name, { isFile: type === "file" });
+			return type === "file" ? resolved : ensureValidVarName(resolved);
 		},
 		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' },
+*       enumType: 'asConst',
+*       optionalType: 'questionTokenAndUndefined',
+*     }),
+*   ],
 * })
 * ```
 */
@@ -1299,7 +1535,7 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
 			return `${camelCase(ctx.group)}Controller`;
 		}
-	} : void 0;
+	} : null;
 	return {
 		name: pluginTsName,
 		options,