@kubb/plugin-ts 5.0.0-alpha.4 → 5.0.0-alpha.6

package/dist/{plugin-Bgm8TNUt.js → plugin-BcK4SBA0.js}

@@ -1,14 +1,14 @@
 import "./chunk--u3MIqq1.js";
-import { A as keywordTypeNodes, C as createTypeDeclaration, D as createUnionDeclaration, E as createTypeReferenceNode, F as camelCase, I as pascalCase, M as syntaxKind, N as jsStringEscape, O as createUrlTemplateType, P as trimQuotes, S as createTypeAliasDeclaration, T as createTypeOperatorNode, _ as createPropertySignature, a as createArrayTypeNode, b as createTrue, c as createIdentifier, d as createIntersectionDeclaration, f as createLiteralTypeNode, g as createPrefixUnaryExpression, h as createOptionalTypeNode, i as createArrayDeclaration, j as modifiers, k as getUnknownType, l as createIndexSignature, m as createOmitDeclaration, n as SyntaxKind, o as createEnumDeclaration, p as createNumericLiteral, r as appendJSDocToNode, s as createFalse, t as Type$1, u as createIndexedAccessTypeNode, v as createRestTypeNode, w as createTypeLiteralNode, x as createTupleTypeNode, y as createStringLiteral } from "./components-CRjwjdyE.js";
+import { A as keywordTypeNodes, C as createTypeDeclaration, D as createUnionDeclaration, E as createTypeReferenceNode, F as camelCase, I as pascalCase, M as syntaxKind, N as jsStringEscape, O as createUrlTemplateType, P as trimQuotes, S as createTypeAliasDeclaration, T as createTypeOperatorNode, _ as createPropertySignature, a as createArrayTypeNode, b as createTrue, c as createIdentifier, d as createIntersectionDeclaration, f as createLiteralTypeNode, g as createPrefixUnaryExpression, h as createOptionalTypeNode, i as createArrayDeclaration, j as modifiers, k as getUnknownType, l as createIndexSignature, m as createOmitDeclaration, n as SyntaxKind, o as createEnumDeclaration, p as createNumericLiteral, r as appendJSDocToNode, s as createFalse, t as Type$1, u as createIndexedAccessTypeNode, v as createRestTypeNode, w as createTypeLiteralNode, x as createTupleTypeNode, y as createStringLiteral } from "./components-CRu8IKY3.js";
 import path from "node:path";
-import { collect, isPlainStringType, walk } from "@kubb/ast";
+import { applyParamsCasing, collect, createProperty, createSchema, isPlainStringType, walk } from "@kubb/ast";
 import { defineGenerator, definePlugin, definePrinter, getBarrelFiles, getMode, resolveOptions } from "@kubb/core";
 import { OperationGenerator, SchemaGenerator, buildOperation, buildSchema, isKeyword, pluginOasName, schemaKeywords } from "@kubb/plugin-oas";
 import { useKubb, useMode, usePluginManager } from "@kubb/core/hooks";
 import { safePrint } from "@kubb/fabric-core/parsers/typescript";
 import { createReactGenerator } from "@kubb/plugin-oas/generators";
 import { useOas, useOperationManager, useSchemaManager } from "@kubb/plugin-oas/hooks";
-import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
+import { applyParamsCasing as applyParamsCasing$1, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
 import { File } from "@kubb/react-fabric";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
@@ -202,7 +202,7 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 const typeGenerator$1 = createReactGenerator({
 	name: "typescript",
 	Operation({ operation, generator, plugin }) {
-		const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
+		const { options, options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
 		const mode = useMode();
 		const pluginManager = usePluginManager();
 		const oas = useOas();
@@ -232,7 +232,7 @@ const typeGenerator$1 = createReactGenerator({
 			schemas.response
 		].flat().filter(Boolean);
 		const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }) => {
-			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing(schema, paramsCasing) : schema;
+			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing$1(schema, paramsCasing) : schema;
 			const tree = schemaGenerator.parse({
 				schema: transformedSchema,
 				name,
@@ -261,7 +261,6 @@ const typeGenerator$1 = createReactGenerator({
 				description,
 				tree,
 				schema: transformedSchema,
-				mapper,
 				enumType,
 				enumKeyCasing,
 				optionalType,
@@ -321,7 +320,7 @@ const typeGenerator$1 = createReactGenerator({
 		});
 	},
 	Schema({ schema, plugin }) {
-		const { options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
+		const { options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
 		const mode = useMode();
 		const oas = useOas();
 		const pluginManager = usePluginManager();
@@ -363,7 +362,6 @@ const typeGenerator$1 = createReactGenerator({
 				description: schema.value.description,
 				tree: schema.tree,
 				schema: schema.value,
-				mapper,
 				enumType,
 				enumKeyCasing,
 				optionalType,
@@ -374,7 +372,45 @@ const typeGenerator$1 = createReactGenerator({
 	}
 });
 //#endregion
+//#region src/constants.ts
+/**
+* `optionalType` values that cause a property's type to include `| undefined`.
+*/
+const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined"]);
+/**
+* `optionalType` values that render the property key with a `?` token.
+*/
+const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
+/**
+* `enumType` values that append a `Key` suffix to the generated enum type alias.
+*/
+const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst", "asPascalConst"]);
+/**
+* `enumType` 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).
+*/
+const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
+	"asConst",
+	"asPascalConst",
+	"literal",
+	void 0
+]);
+//#endregion
 //#region src/printer.ts
+/**
+* Converts a primitive const value to a TypeScript literal type node.
+* Handles negative numbers via a prefix unary expression.
+*/
 function constToTypeNode(value, format) {
 	if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
 	if (format === "number" && typeof value === "number") {
@@ -383,12 +419,22 @@ function constToTypeNode(value, format) {
 	}
 	return createLiteralTypeNode(createStringLiteral(String(value)));
 }
+/**
+* Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.
+*/
 function dateOrStringNode(node) {
 	return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
 }
+/**
+* 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);
 }
+/**
+* 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);
 	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
@@ -401,13 +447,19 @@ function buildTupleNode(node, print) {
 	if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
 	return createTupleTypeNode(items);
 }
+/**
+* Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
+*/
 function buildPropertyType(schema, baseType, optionalType) {
-	const addsUndefined = ["undefined", "questionTokenAndUndefined"].includes(optionalType);
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
 	let type = baseType;
 	if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
 	if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
+/**
+* Collects JSDoc annotation strings (description, deprecated, min/max, pattern, default, example, type) for a schema node.
+*/
 function buildPropertyJSDocComments(schema) {
 	return [
 		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
@@ -420,6 +472,9 @@ function buildPropertyJSDocComments(schema) {
 		"primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
 	];
 }
+/**
+* Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
+*/
 function buildIndexSignatures(node, propertyCount, print) {
 	const elements = [];
 	if (node.additionalProperties && node.additionalProperties !== true) {
@@ -437,224 +492,405 @@ function buildIndexSignatures(node, propertyCount, print) {
 	return elements;
 }
 /**
-* Converts a `SchemaNode` AST node into a TypeScript `ts.TypeNode`.
+* TypeScript type printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST node into a TypeScript AST node:
+* - **`printer.print(node)`** — when `options.typeName` is set, returns a full
+*   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
+*   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
 *
-* Built on `definePrinter` — dispatches on `node.type`, with options closed over
-* per printer instance. Produces the same `ts.TypeNode` output as the keyword-based
-* `parse` in `parser.ts`.
+* Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
+* over per printer instance, so each call to `printerTs(options)` produces an independent printer.
+*
+* @example Raw type node (no `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: '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 declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+* ```
 */
-const printerTs = definePrinter((options) => ({
-	name: "typescript",
-	options,
-	nodes: {
-		any: () => keywordTypeNodes.any,
-		unknown: () => keywordTypeNodes.unknown,
-		void: () => keywordTypeNodes.void,
-		boolean: () => keywordTypeNodes.boolean,
-		null: () => keywordTypeNodes.null,
-		blob: () => createTypeReferenceNode("Blob", []),
-		string: () => keywordTypeNodes.string,
-		uuid: () => keywordTypeNodes.string,
-		email: () => keywordTypeNodes.string,
-		url: () => keywordTypeNodes.string,
-		datetime: () => keywordTypeNodes.string,
-		number: () => keywordTypeNodes.number,
-		integer: () => keywordTypeNodes.number,
-		bigint: () => keywordTypeNodes.bigint,
-		date: (node) => dateOrStringNode(node),
-		time: (node) => dateOrStringNode(node),
-		ref(node) {
-			if (!node.name) return;
-			return createTypeReferenceNode(node.name, void 0);
-		},
-		enum(node) {
-			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).map((value) => constToTypeNode(value, typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string")).filter(Boolean)
-			}) ?? void 0;
-			return createTypeReferenceNode(["asConst", "asPascalConst"].includes(this.options.enumType) ? `${node.name}Key` : node.name, void 0);
-		},
-		union(node) {
-			const members = node.members ?? [];
-			const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
-			const hasPlainString = members.some((m) => isPlainStringType(m));
-			if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
-				withParentheses: true,
-				nodes: members.map((m) => {
-					if (isPlainStringType(m)) return createIntersectionDeclaration({
-						nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
-						withParentheses: true
+const printerTs = definePrinter((options) => {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+	return {
+		name: "typescript",
+		options,
+		nodes: {
+			any: () => keywordTypeNodes.any,
+			unknown: () => keywordTypeNodes.unknown,
+			void: () => keywordTypeNodes.void,
+			never: () => keywordTypeNodes.never,
+			boolean: () => keywordTypeNodes.boolean,
+			null: () => keywordTypeNodes.null,
+			blob: () => createTypeReferenceNode("Blob", []),
+			string: () => keywordTypeNodes.string,
+			uuid: () => keywordTypeNodes.string,
+			email: () => keywordTypeNodes.string,
+			url: (node) => {
+				if (node.path) return createUrlTemplateType(node.path);
+				return keywordTypeNodes.string;
+			},
+			datetime: () => keywordTypeNodes.string,
+			number: () => keywordTypeNodes.number,
+			integer: () => keywordTypeNodes.number,
+			bigint: () => keywordTypeNodes.bigint,
+			date: dateOrStringNode,
+			time: dateOrStringNode,
+			ref(node) {
+				if (!node.name) return;
+				return createTypeReferenceNode(node.name, void 0);
+			},
+			enum(node) {
+				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).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+				}) ?? void 0;
+				const resolvedName = pascalCase(node.name);
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) ? `${resolvedName}Key` : resolvedName, void 0);
+			},
+			union(node) {
+				const members = node.members ?? [];
+				const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+				const hasPlainString = members.some((m) => isPlainStringType(m));
+				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
+					withParentheses: true,
+					nodes: members.map((m) => {
+						if (isPlainStringType(m)) return createIntersectionDeclaration({
+							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+							withParentheses: true
+						});
+						return this.print(m);
+					}).filter(Boolean)
+				}) ?? void 0;
+				return createUnionDeclaration({
+					withParentheses: true,
+					nodes: buildMemberNodes(members, this.print)
+				}) ?? void 0;
+			},
+			intersection(node) {
+				return createIntersectionDeclaration({
+					withParentheses: true,
+					nodes: buildMemberNodes(node.members, this.print)
+				}) ?? void 0;
+			},
+			array(node) {
+				return createArrayDeclaration({
+					nodes: (node.items ?? []).map((item) => this.print(item)).filter(Boolean),
+					arrayType: this.options.arrayType
+				}) ?? void 0;
+			},
+			tuple(node) {
+				return buildTupleNode(node, this.print);
+			},
+			object(node) {
+				const { print, options } = this;
+				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
+				const propertyNodes = node.properties.map((prop) => {
+					const baseType = print(prop.schema) ?? keywordTypeNodes.unknown;
+					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
+					return appendJSDocToNode({
+						node: createPropertySignature({
+							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+							name: prop.name,
+							type,
+							readOnly: prop.schema.readOnly
+						}),
+						comments: buildPropertyJSDocComments(prop.schema)
 					});
-					return this.print(m);
-				}).filter(Boolean)
-			}) ?? void 0;
-			return createUnionDeclaration({
-				withParentheses: true,
-				nodes: buildMemberNodes(members, this.print)
-			}) ?? void 0;
-		},
-		intersection(node) {
-			return createIntersectionDeclaration({
-				withParentheses: true,
-				nodes: buildMemberNodes(node.members, this.print)
-			}) ?? void 0;
-		},
-		array(node) {
-			return createArrayDeclaration({
-				nodes: (node.items ?? []).map((item) => this.print(item)).filter(Boolean),
-				arrayType: this.options.arrayType
-			}) ?? void 0;
-		},
-		tuple(node) {
-			return buildTupleNode(node, this.print);
-		},
-		object(node) {
-			const addsQuestionToken = ["questionToken", "questionTokenAndUndefined"].includes(this.options.optionalType);
-			const { print } = this;
-			const propertyNodes = node.properties.map((prop) => {
-				const baseType = print(prop.schema) ?? keywordTypeNodes.unknown;
-				const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
-				return appendJSDocToNode({
-					node: createPropertySignature({
-						questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-						name: prop.name,
-						type,
-						readOnly: prop.schema.readOnly
-					}),
-					comments: buildPropertyJSDocComments(prop.schema)
 				});
+				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
+				if (!allElements.length) return keywordTypeNodes.object;
+				return createTypeLiteralNode(allElements);
+			}
+		},
+		print(node) {
+			let type = this.print(node);
+			if (!type) return;
+			if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+			if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+			const { typeName, syntaxType = "type", description, keysToOmit } = this.options;
+			if (!typeName) return type;
+			const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!keysToOmit?.length;
+			return createTypeDeclaration({
+				name: typeName,
+				isExportable: true,
+				type: keysToOmit?.length ? createOmitDeclaration({
+					keys: keysToOmit,
+					type,
+					nonNullable: true
+				}) : type,
+				syntax: useTypeGeneration ? "type" : "interface",
+				comments: [
+					node?.title ? jsStringEscape(node.title) : void 0,
+					description ? `@description ${jsStringEscape(description)}` : void 0,
+					node?.deprecated ? "@deprecated" : void 0,
+					node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
+					node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
+					node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
+					node?.default ? `@default ${node.default}` : void 0,
+					node?.example ? `@example ${node.example}` : void 0
+				]
 			});
-			const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
-			if (!allElements.length) return keywordTypeNodes.object;
-			return createTypeLiteralNode(allElements);
 		}
-	}
-}));
+	};
+});
+//#endregion
+//#region src/components/v2/Enum.tsx
+/**
+* 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. `pascalCase` normalizes it unconditionally; for inline enum
+* properties the adapter already emits a PascalCase+suffix name so `pascalCase` is a no-op.
+*/
+function getEnumNames(node, enumType) {
+	const resolved = pascalCase(node.name);
+	return {
+		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : 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
+* - 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, enumKeyCasing }) {
+	const { enumName, typeName } = getEnumNames(node, enumType);
+	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
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
+		name: enumName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: false,
+		children: safePrint(nameNode)
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isIndexable: true,
+		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
+		children: safePrint(typeNode)
+	})] });
+}
 //#endregion
 //#region src/components/v2/Type.tsx
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
-	const typeNodes = [];
-	const description = rest.description || node?.description;
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description }) {
+	const resolvedDescription = description || node?.description;
 	const enumSchemaNodes = collect(node, { schema(n) {
 		if (n.type === "enum" && n.name) return n;
 	} });
-	let type = printerTs({
+	const typeNode = printerTs({
 		optionalType,
 		arrayType,
-		enumType
+		enumType,
+		typeName: name,
+		syntaxType,
+		description: resolvedDescription,
+		keysToOmit
 	}).print(node);
-	if (!type) return;
-	if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
-		const isDirectEnum = node.type === "array" && node.items !== void 0;
-		const isEnumOnly = "enum" in node && node.enum;
-		if (isDirectEnum || isEnumOnly) {
-			type = createTypeReferenceNode(`${enumSchemaNodes[0].name}Key`);
-			if (isDirectEnum) if (arrayType === "generic") type = createTypeReferenceNode(createIdentifier("Array"), [type]);
-			else type = createArrayTypeNode(type);
-		}
-	}
-	if (node) {
-		if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-		if (node.nullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-		if (node.optional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-	}
-	const useTypeGeneration = syntaxType === "type" || [syntaxKind.union].includes(type.kind) || !!keysToOmit?.length;
-	typeNodes.push(createTypeDeclaration({
-		name,
-		isExportable: true,
-		type: keysToOmit?.length ? createOmitDeclaration({
-			keys: keysToOmit,
-			type,
-			nonNullable: true
-		}) : type,
-		syntax: useTypeGeneration ? "type" : "interface",
-		comments: [
-			node?.title ? `${jsStringEscape(node.title)}` : void 0,
-			description ? `@description ${jsStringEscape(description)}` : void 0,
-			node?.deprecated ? "@deprecated" : void 0,
-			node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
-			node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
-			node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
-			node?.default ? `@default ${node.default}` : void 0,
-			node?.example ? `@example ${node.example}` : void 0
-		]
-	}));
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((enumSchemaNode) => {
-		const enumName = enumType === "asPascalConst" ? pascalCase(enumSchemaNode.name) : camelCase(enumSchemaNode.name);
-		const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchemaNode.name}Key` : enumSchemaNode.name;
-		const [nameNode, typeNode] = createEnumDeclaration({
-			name: enumName,
-			typeName,
-			enums: enumSchemaNode.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? enumSchemaNode.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
-			type: enumType,
-			enumKeyCasing
-		});
+	if (!typeNode) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
 		return {
-			nameNode,
-			typeNode,
-			name: enumName,
-			typeName
+			node,
+			...getEnumNames(node, enumType)
 		};
 	});
 	const shouldExportEnums = enumType !== "inlineLiteral";
 	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ name: enumName, nameNode, typeName, typeNode }) => /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
-		name: enumName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: false,
-		children: safePrint(nameNode)
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isIndexable: true,
-		isExportable: [
-			"enum",
-			"asConst",
-			"asPascalConst",
-			"constEnum",
-			"literal",
-			void 0
-		].includes(enumType),
-		isTypeOnly: [
-			"asConst",
-			"asPascalConst",
-			"literal",
-			void 0
-		].includes(enumType),
-		children: safePrint(typeNode)
-	})] })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enumType,
+		enumKeyCasing
+	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
 		name: typedName,
 		isTypeOnly: true,
 		isExportable: true,
 		isIndexable: true,
-		children: safePrint(...typeNodes)
+		children: safePrint(typeNode)
 	})] });
 }
 //#endregion
+//#region src/generators/v2/utils.ts
+/**
+* Builds an `ObjectSchemaNode` for a group of parameters (path/query/header).
+* Each property is a `ref` schema pointing to the individually-resolved parameter type.
+* The ref name includes the parameter location so generated type names follow
+* the `<OperationId><Location><ParamName>` convention.
+*/
+function buildParamsSchema({ params, operationId, resolveName }) {
+	return createSchema({
+		type: "object",
+		properties: params.map((param) => createProperty({
+			name: param.name,
+			schema: createSchema({
+				type: "ref",
+				name: resolveName({
+					name: `${operationId} ${pascalCase(param.in)} ${param.name}`,
+					type: "function"
+				}),
+				optional: !param.required
+			})
+		}))
+	});
+}
+/**
+* Builds an `ObjectSchemaNode` representing the `<OperationId>RequestConfig` type:
+* - `data`         → request body ref (optional) or `never`
+* - `pathParams`   → inline object of path param refs, or `never`
+* - `queryParams`  → inline object of query param refs (optional), or `never`
+* - `headerParams` → inline object of header param refs (optional), or `never`
+* - `url`          → Express-style template literal (plugin-ts extension, handled by printer)
+*/
+function buildDataSchemaNode({ node, resolveName }) {
+	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");
+	return createSchema({
+		type: "object",
+		properties: [
+			createProperty({
+				name: "data",
+				schema: node.requestBody ? createSchema({
+					type: "ref",
+					name: resolveName({
+						name: `${node.operationId} Data`,
+						type: "function"
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "pathParams",
+				schema: pathParams.length > 0 ? buildParamsSchema({
+					params: pathParams,
+					operationId: node.operationId,
+					resolveName
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "queryParams",
+				schema: queryParams.length > 0 ? createSchema({
+					...buildParamsSchema({
+						params: queryParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "headerParams",
+				schema: headerParams.length > 0 ? createSchema({
+					...buildParamsSchema({
+						params: headerParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "url",
+				schema: createSchema({
+					type: "url",
+					path: node.path
+				})
+			})
+		]
+	});
+}
+/**
+* Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
+* Numeric status codes produce unquoted numeric keys (e.g. `200:`).
+*/
+function buildResponsesSchemaNode({ node, resolveName }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "object",
+		properties: responsesWithSchema.map((res) => createProperty({
+			name: String(res.statusCode),
+			schema: createSchema({
+				type: "ref",
+				name: resolveName({
+					name: `${node.operationId} Status ${res.statusCode}`,
+					type: "function"
+				})
+			})
+		}))
+	});
+}
+/**
+* Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
+* Returns `null` when the operation has no responses with schemas.
+*/
+function buildResponseUnionSchemaNode({ node, resolveName }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => createSchema({
+			type: "ref",
+			name: resolveName({
+				name: `${node.operationId} Status ${res.statusCode}`,
+				type: "function"
+			})
+		}))
+	});
+}
+//#endregion
 //#region src/generators/v2/typeGenerator.tsx
 const typeGenerator = defineGenerator({
 	name: "typescript",
 	type: "react",
 	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
-		const { plugin, mode, getFile, resolveName } = useKubb();
+		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
+		const { mode, getFile, resolveName } = useKubb();
 		const file = getFile({
 			name: node.operationId,
-			pluginName: plugin.name,
 			extname: ".ts",
-			mode
+			mode,
+			options: { group: group ? group.type === "tag" ? { tag: node.tags[0] } : { path: node.path } : void 0 }
 		});
+		const params = applyParamsCasing(node.parameters, paramsCasing);
 		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+			if (!schemaNode) return null;
 			const imports = adapter.getImports(schemaNode, (schemaName) => ({
 				name: resolveName({
 					name: schemaName,
-					pluginName: plugin.name,
 					type: "type"
 				}),
 				path: getFile({
 					name: schemaName,
-					pluginName: plugin.name,
 					extname: ".ts",
 					mode
 				}).path
@@ -680,60 +916,87 @@ const typeGenerator = defineGenerator({
 				syntaxType
 			})] });
 		}
-		const paramTypes = node.parameters.map((param) => {
-			const name = resolveName({
-				name: `${node.operationId} ${param.name}`,
-				pluginName: plugin.name,
+		const paramTypes = params.map((param) => renderSchemaType({
+			node: param.schema,
+			name: resolveName({
+				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
 				type: "function"
-			});
-			const typedName = resolveName({
-				name: `${node.operationId} ${param.name}`,
-				pluginName: plugin.name,
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
 				type: "type"
-			});
-			return renderSchemaType({
-				node: param.schema,
-				name,
-				typedName
-			});
+			})
+		}));
+		const responseTypes = node.responses.filter((res) => res.schema).map((res) => renderSchemaType({
+			node: res.schema,
+			name: resolveName({
+				name: `${node.operationId} Status ${res.statusCode}`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Status ${res.statusCode}`,
+				type: "type"
+			}),
+			description: res.description
+		}));
+		const requestType = node.requestBody ? renderSchemaType({
+			node: node.requestBody,
+			name: resolveName({
+				name: `${node.operationId} Data`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Data`,
+				type: "type"
+			}),
+			description: node.requestBody.description
+		}) : null;
+		const dataType = renderSchemaType({
+			node: buildDataSchemaNode({
+				node: {
+					...node,
+					parameters: params
+				},
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} RequestConfig`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} RequestConfig`,
+				type: "type"
+			})
 		});
-		const responseTypes = node.responses.filter((res) => res.schema).map((res) => {
-			const schemaNode = res.schema;
-			const responseName = `${node.operationId} ${res.statusCode}`;
-			return renderSchemaType({
-				node: schemaNode,
-				name: resolveName({
-					name: responseName,
-					pluginName: plugin.name,
-					type: "function"
-				}),
-				typedName: resolveName({
-					name: responseName,
-					pluginName: plugin.name,
-					type: "type"
-				}),
-				description: res.description
-			});
+		const responsesType = renderSchemaType({
+			node: buildResponsesSchemaNode({
+				node,
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} Responses`,
+				type: "function"
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Responses`,
+				type: "type"
+			})
 		});
-		const requestType = node.requestBody ? (() => {
-			const requestName = `${node.operationId} MutationRequest`;
-			const resolvedName = resolveName({
-				name: requestName,
-				pluginName: plugin.name,
+		const responseType = renderSchemaType({
+			node: buildResponseUnionSchemaNode({
+				node,
+				resolveName
+			}),
+			name: resolveName({
+				name: `${node.operationId} Response`,
 				type: "function"
-			});
-			const typedName = resolveName({
-				name: requestName,
-				pluginName: plugin.name,
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} Response`,
 				type: "type"
-			});
-			return renderSchemaType({
-				node: node.requestBody,
-				name: resolvedName,
-				typedName,
-				description: node.requestBody.description
-			});
-		})() : null;
+			}),
+			description: "Union of all possible responses"
+		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: file.baseName,
 			path: file.path,
@@ -741,23 +1004,24 @@ const typeGenerator = defineGenerator({
 			children: [
 				paramTypes,
 				responseTypes,
-				requestType
+				requestType,
+				dataType,
+				responsesType,
+				responseType
 			]
 		});
 	},
 	Schema({ node, adapter, options }) {
 		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-		const { plugin, mode, resolveName, getFile } = useKubb();
+		const { mode, resolveName, getFile } = useKubb();
 		if (!node.name) return;
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolveName({
 				name: schemaName,
-				pluginName: plugin.name,
 				type: "type"
 			}),
 			path: getFile({
 				name: schemaName,
-				pluginName: plugin.name,
 				extname: ".ts",
 				mode
 			}).path
@@ -765,20 +1029,17 @@ const typeGenerator = defineGenerator({
 		const isEnumSchema = node.type === "enum";
 		let typedName = resolveName({
 			name: node.name,
-			pluginName: plugin.name,
 			type: "type"
 		});
-		if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName = typedName += "Key";
+		if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema) typedName += "Key";
 		const type = {
 			name: resolveName({
 				name: node.name,
-				pluginName: plugin.name,
 				type: "function"
 			}),
 			typedName,
 			file: getFile({
 				name: node.name,
-				pluginName: plugin.name,
 				extname: ".ts",
 				mode
 			})
@@ -816,7 +1077,7 @@ const pluginTs = definePlugin((options) => {
 	const { output = {
 		path: "types",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+	}, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
 	return {
 		name: pluginTsName,
 		options: {
@@ -834,7 +1095,6 @@ const pluginTs = definePlugin((options) => {
 			syntaxType,
 			group,
 			override,
-			mapper,
 			paramsCasing,
 			usedEnumNames: {}
 		},
@@ -919,6 +1179,13 @@ const pluginTs = definePlugin((options) => {
 						await Promise.all(writeTasks);
 					}
 				}, { depth: "shallow" });
+				const barrelFiles = await getBarrelFiles(this.fabric.files, {
+					type: output.barrelType ?? "named",
+					root,
+					output,
+					meta: { pluginName: this.plugin.name }
+				});
+				await this.upsertFile(...barrelFiles);
 				return;
 			}
 			const oas = await this.getOas();
@@ -962,4 +1229,4 @@ const pluginTs = definePlugin((options) => {
 //#endregion
 export { typeGenerator$1 as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
 
-//# sourceMappingURL=plugin-Bgm8TNUt.js.map
+//# sourceMappingURL=plugin-BcK4SBA0.js.map