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

package/dist/{plugin-DvK-Uhvv.cjs → plugin-BrQcApyO.cjs}

@@ -1,4 +1,4 @@
-const require_components = require("./components-DI0aTIBg.cjs");
+const require_components = require("./components-DeNDKlzf.cjs");
 let node_path = require("node:path");
 node_path = require_components.__toESM(node_path);
 let _kubb_ast = require("@kubb/ast");
@@ -217,7 +217,7 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 const typeGenerator$1 = (0, _kubb_plugin_oas_generators.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 = (0, _kubb_core_hooks.useMode)();
 		const pluginManager = (0, _kubb_core_hooks.usePluginManager)();
 		const oas = (0, _kubb_plugin_oas_hooks.useOas)();
@@ -276,7 +276,6 @@ const typeGenerator$1 = (0, _kubb_plugin_oas_generators.createReactGenerator)({
 				description,
 				tree,
 				schema: transformedSchema,
-				mapper,
 				enumType,
 				enumKeyCasing,
 				optionalType,
@@ -336,7 +335,7 @@ const typeGenerator$1 = (0, _kubb_plugin_oas_generators.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 = (0, _kubb_core_hooks.useMode)();
 		const oas = (0, _kubb_plugin_oas_hooks.useOas)();
 		const pluginManager = (0, _kubb_core_hooks.usePluginManager)();
@@ -378,7 +377,6 @@ const typeGenerator$1 = (0, _kubb_plugin_oas_generators.createReactGenerator)({
 				description: schema.value.description,
 				tree: schema.tree,
 				schema: schema.value,
-				mapper,
 				enumType,
 				enumKeyCasing,
 				optionalType,
@@ -389,7 +387,45 @@ const typeGenerator$1 = (0, _kubb_plugin_oas_generators.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 require_components.createLiteralTypeNode(value === true ? require_components.createTrue() : require_components.createFalse());
 	if (format === "number" && typeof value === "number") {
@@ -398,12 +434,22 @@ function constToTypeNode(value, format) {
 	}
 	return require_components.createLiteralTypeNode(require_components.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" ? require_components.createTypeReferenceNode(require_components.createIdentifier("Date")) : require_components.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;
@@ -416,13 +462,19 @@ function buildTupleNode(node, print) {
 	if (max === void 0 && restNode) items.push(require_components.createRestTypeNode(require_components.createArrayTypeNode(restNode)));
 	return require_components.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 = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
 	if ((schema.nullish || schema.optional) && addsUndefined) type = require_components.createUnionDeclaration({ nodes: [type, require_components.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 ${require_components.jsStringEscape(schema.description)}` : void 0,
@@ -435,6 +487,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) {
@@ -452,234 +507,414 @@ 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 = (0, _kubb_core.definePrinter)((options) => ({
-	name: "typescript",
-	options,
-	nodes: {
-		any: () => require_components.keywordTypeNodes.any,
-		unknown: () => require_components.keywordTypeNodes.unknown,
-		void: () => require_components.keywordTypeNodes.void,
-		boolean: () => require_components.keywordTypeNodes.boolean,
-		null: () => require_components.keywordTypeNodes.null,
-		blob: () => require_components.createTypeReferenceNode("Blob", []),
-		string: () => require_components.keywordTypeNodes.string,
-		uuid: () => require_components.keywordTypeNodes.string,
-		email: () => require_components.keywordTypeNodes.string,
-		url: () => require_components.keywordTypeNodes.string,
-		datetime: () => require_components.keywordTypeNodes.string,
-		number: () => require_components.keywordTypeNodes.number,
-		integer: () => require_components.keywordTypeNodes.number,
-		bigint: () => require_components.keywordTypeNodes.bigint,
-		date: (node) => dateOrStringNode(node),
-		time: (node) => dateOrStringNode(node),
-		ref(node) {
-			if (!node.name) return;
-			return require_components.createTypeReferenceNode(node.name, void 0);
-		},
-		enum(node) {
-			const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
-			if (this.options.enumType === "inlineLiteral" || !node.name) {
-				const literalNodes = values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string")).filter(Boolean);
+const printerTs = (0, _kubb_core.definePrinter)((options) => {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+	return {
+		name: "typescript",
+		options,
+		nodes: {
+			any: () => require_components.keywordTypeNodes.any,
+			unknown: () => require_components.keywordTypeNodes.unknown,
+			void: () => require_components.keywordTypeNodes.void,
+			never: () => require_components.keywordTypeNodes.never,
+			boolean: () => require_components.keywordTypeNodes.boolean,
+			null: () => require_components.keywordTypeNodes.null,
+			blob: () => require_components.createTypeReferenceNode("Blob", []),
+			string: () => require_components.keywordTypeNodes.string,
+			uuid: () => require_components.keywordTypeNodes.string,
+			email: () => require_components.keywordTypeNodes.string,
+			url: (node) => {
+				if (node.path) return require_components.createUrlTemplateType(node.path);
+				return require_components.keywordTypeNodes.string;
+			},
+			datetime: () => require_components.keywordTypeNodes.string,
+			number: () => require_components.keywordTypeNodes.number,
+			integer: () => require_components.keywordTypeNodes.number,
+			bigint: () => require_components.keywordTypeNodes.bigint,
+			date: dateOrStringNode,
+			time: dateOrStringNode,
+			ref(node) {
+				if (!node.name) return;
+				return require_components.createTypeReferenceNode(node.name, void 0);
+			},
+			enum(node) {
+				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
+				if (this.options.enumType === "inlineLiteral" || !node.name) {
+					const literalNodes = values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean);
+					return require_components.createUnionDeclaration({
+						withParentheses: true,
+						nodes: literalNodes
+					}) ?? void 0;
+				}
+				const resolvedName = require_components.pascalCase(node.name);
+				const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) ? `${resolvedName}Key` : resolvedName;
+				return require_components.createTypeReferenceNode(typeName, void 0);
+			},
+			union(node) {
+				const members = node.members ?? [];
+				const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+				const hasPlainString = members.some((m) => (0, _kubb_ast.isPlainStringType)(m));
+				if (hasStringLiteral && hasPlainString) {
+					const memberNodes = members.map((m) => {
+						if ((0, _kubb_ast.isPlainStringType)(m)) return require_components.createIntersectionDeclaration({
+							nodes: [require_components.keywordTypeNodes.string, require_components.createTypeLiteralNode([])],
+							withParentheses: true
+						});
+						return this.print(m);
+					}).filter(Boolean);
+					return require_components.createUnionDeclaration({
+						withParentheses: true,
+						nodes: memberNodes
+					}) ?? void 0;
+				}
 				return require_components.createUnionDeclaration({
 					withParentheses: true,
-					nodes: literalNodes
+					nodes: buildMemberNodes(members, this.print)
 				}) ?? void 0;
-			}
-			const typeName = ["asConst", "asPascalConst"].includes(this.options.enumType) ? `${node.name}Key` : node.name;
-			return require_components.createTypeReferenceNode(typeName, void 0);
-		},
-		union(node) {
-			const members = node.members ?? [];
-			const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
-			const hasPlainString = members.some((m) => (0, _kubb_ast.isPlainStringType)(m));
-			if (hasStringLiteral && hasPlainString) {
-				const nodes = members.map((m) => {
-					if ((0, _kubb_ast.isPlainStringType)(m)) return require_components.createIntersectionDeclaration({
-						nodes: [require_components.keywordTypeNodes.string, require_components.createTypeLiteralNode([])],
-						withParentheses: true
-					});
-					return this.print(m);
-				}).filter(Boolean);
-				return require_components.createUnionDeclaration({
+			},
+			intersection(node) {
+				return require_components.createIntersectionDeclaration({
 					withParentheses: true,
-					nodes
+					nodes: buildMemberNodes(node.members, this.print)
+				}) ?? void 0;
+			},
+			array(node) {
+				const itemNodes = (node.items ?? []).map((item) => this.print(item)).filter(Boolean);
+				return require_components.createArrayDeclaration({
+					nodes: itemNodes,
+					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) ?? require_components.keywordTypeNodes.unknown;
+					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
+					const propertyNode = require_components.createPropertySignature({
+						questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+						name: prop.name,
+						type,
+						readOnly: prop.schema.readOnly
+					});
+					return require_components.appendJSDocToNode({
+						node: propertyNode,
+						comments: buildPropertyJSDocComments(prop.schema)
+					});
+				});
+				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
+				if (!allElements.length) return require_components.keywordTypeNodes.object;
+				return require_components.createTypeLiteralNode(allElements);
 			}
-			return require_components.createUnionDeclaration({
-				withParentheses: true,
-				nodes: buildMemberNodes(members, this.print)
-			}) ?? void 0;
-		},
-		intersection(node) {
-			return require_components.createIntersectionDeclaration({
-				withParentheses: true,
-				nodes: buildMemberNodes(node.members, this.print)
-			}) ?? void 0;
 		},
-		array(node) {
-			const itemNodes = (node.items ?? []).map((item) => this.print(item)).filter(Boolean);
-			return require_components.createArrayDeclaration({
-				nodes: itemNodes,
-				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) ?? require_components.keywordTypeNodes.unknown;
-				const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
-				const propertyNode = require_components.createPropertySignature({
-					questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-					name: prop.name,
+		print(node) {
+			let type = this.print(node);
+			if (!type) return;
+			if (node.nullable) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
+			if ((node.nullish || node.optional) && addsUndefined) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
+			const { typeName, syntaxType = "type", description, keysToOmit } = this.options;
+			if (!typeName) return type;
+			const useTypeGeneration = syntaxType === "type" || type.kind === require_components.syntaxKind.union || !!keysToOmit?.length;
+			return require_components.createTypeDeclaration({
+				name: typeName,
+				isExportable: true,
+				type: keysToOmit?.length ? require_components.createOmitDeclaration({
+					keys: keysToOmit,
 					type,
-					readOnly: prop.schema.readOnly
-				});
-				return require_components.appendJSDocToNode({
-					node: propertyNode,
-					comments: buildPropertyJSDocComments(prop.schema)
-				});
+					nonNullable: true
+				}) : type,
+				syntax: useTypeGeneration ? "type" : "interface",
+				comments: [
+					node?.title ? require_components.jsStringEscape(node.title) : void 0,
+					description ? `@description ${require_components.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 require_components.keywordTypeNodes.object;
-			return require_components.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 = require_components.pascalCase(node.name);
+	return {
+		enumName: enumType === "asPascalConst" ? resolved : require_components.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] = require_components.createEnumDeclaration({
+		name: enumName,
+		typeName,
+		enums: node.namedEnumValues?.map((v) => [require_components.trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [require_components.trimQuotes(v.toString()), v]) ?? [],
+		type: enumType,
+		enumKeyCasing
+	});
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+		name: enumName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: false,
+		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(nameNode)
+	}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.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_fabric_core_parsers_typescript.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 = (0, _kubb_ast.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) {
-			const typeNameWithKey = `${enumSchemaNodes[0].name}Key`;
-			type = require_components.createTypeReferenceNode(typeNameWithKey);
-			if (isDirectEnum) if (arrayType === "generic") type = require_components.createTypeReferenceNode(require_components.createIdentifier("Array"), [type]);
-			else type = require_components.createArrayTypeNode(type);
-		}
-	}
-	if (node) {
-		if (node.nullable) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
-		if (node.nullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
-		if (node.optional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
-	}
-	const useTypeGeneration = syntaxType === "type" || [require_components.syntaxKind.union].includes(type.kind) || !!keysToOmit?.length;
-	typeNodes.push(require_components.createTypeDeclaration({
-		name,
-		isExportable: true,
-		type: keysToOmit?.length ? require_components.createOmitDeclaration({
-			keys: keysToOmit,
-			type,
-			nonNullable: true
-		}) : type,
-		syntax: useTypeGeneration ? "type" : "interface",
-		comments: [
-			node?.title ? `${require_components.jsStringEscape(node.title)}` : void 0,
-			description ? `@description ${require_components.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" ? require_components.pascalCase(enumSchemaNode.name) : require_components.camelCase(enumSchemaNode.name);
-		const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchemaNode.name}Key` : enumSchemaNode.name;
-		const [nameNode, typeNode] = require_components.createEnumDeclaration({
-			name: enumName,
-			typeName,
-			enums: enumSchemaNode.namedEnumValues?.map((v) => [require_components.trimQuotes(v.name.toString()), v.value]) ?? enumSchemaNode.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [require_components.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ name: enumName, nameNode, typeName, typeNode }) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-		name: enumName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: false,
-		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(nameNode)
-	}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.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: (0, _kubb_fabric_core_parsers_typescript.safePrint)(typeNode)
-	})] })), shouldExportType && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Enum, {
+		node,
+		enumType,
+		enumKeyCasing
+	})), shouldExportType && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
 		name: typedName,
 		isTypeOnly: true,
 		isExportable: true,
 		isIndexable: true,
-		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(...typeNodes)
+		children: (0, _kubb_fabric_core_parsers_typescript.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 (0, _kubb_ast.createSchema)({
+		type: "object",
+		properties: params.map((param) => (0, _kubb_ast.createProperty)({
+			name: param.name,
+			schema: (0, _kubb_ast.createSchema)({
+				type: "ref",
+				name: resolveName({
+					name: `${operationId} ${require_components.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 (0, _kubb_ast.createSchema)({
+		type: "object",
+		properties: [
+			(0, _kubb_ast.createProperty)({
+				name: "data",
+				schema: node.requestBody ? (0, _kubb_ast.createSchema)({
+					type: "ref",
+					name: resolveName({
+						name: `${node.operationId} Data`,
+						type: "function"
+					}),
+					optional: true
+				}) : (0, _kubb_ast.createSchema)({
+					type: "never",
+					optional: true
+				})
+			}),
+			(0, _kubb_ast.createProperty)({
+				name: "pathParams",
+				schema: pathParams.length > 0 ? buildParamsSchema({
+					params: pathParams,
+					operationId: node.operationId,
+					resolveName
+				}) : (0, _kubb_ast.createSchema)({
+					type: "never",
+					optional: true
+				})
+			}),
+			(0, _kubb_ast.createProperty)({
+				name: "queryParams",
+				schema: queryParams.length > 0 ? (0, _kubb_ast.createSchema)({
+					...buildParamsSchema({
+						params: queryParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : (0, _kubb_ast.createSchema)({
+					type: "never",
+					optional: true
+				})
+			}),
+			(0, _kubb_ast.createProperty)({
+				name: "headerParams",
+				schema: headerParams.length > 0 ? (0, _kubb_ast.createSchema)({
+					...buildParamsSchema({
+						params: headerParams,
+						operationId: node.operationId,
+						resolveName
+					}),
+					optional: true
+				}) : (0, _kubb_ast.createSchema)({
+					type: "never",
+					optional: true
+				})
+			}),
+			(0, _kubb_ast.createProperty)({
+				name: "url",
+				schema: (0, _kubb_ast.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 (0, _kubb_ast.createSchema)({
+		type: "object",
+		properties: responsesWithSchema.map((res) => (0, _kubb_ast.createProperty)({
+			name: String(res.statusCode),
+			schema: (0, _kubb_ast.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 (0, _kubb_ast.createSchema)({
+		type: "union",
+		members: responsesWithSchema.map((res) => (0, _kubb_ast.createSchema)({
+			type: "ref",
+			name: resolveName({
+				name: `${node.operationId} Status ${res.statusCode}`,
+				type: "function"
+			})
+		}))
+	});
+}
+//#endregion
 //#region src/generators/v2/typeGenerator.tsx
 const typeGenerator = (0, _kubb_core.defineGenerator)({
 	name: "typescript",
 	type: "react",
 	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
-		const { plugin, mode, getFile, resolveName } = (0, _kubb_core_hooks.useKubb)();
+		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
+		const { mode, getFile, resolveName } = (0, _kubb_core_hooks.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 = (0, _kubb_ast.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
@@ -705,60 +940,87 @@ const typeGenerator = (0, _kubb_core.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} ${require_components.pascalCase(param.in)} ${param.name}`,
 				type: "function"
-			});
-			const typedName = resolveName({
-				name: `${node.operationId} ${param.name}`,
-				pluginName: plugin.name,
+			}),
+			typedName: resolveName({
+				name: `${node.operationId} ${require_components.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
 			baseName: file.baseName,
 			path: file.path,
@@ -766,23 +1028,24 @@ const typeGenerator = (0, _kubb_core.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 } = (0, _kubb_core_hooks.useKubb)();
+		const { mode, resolveName, getFile } = (0, _kubb_core_hooks.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
@@ -790,20 +1053,17 @@ const typeGenerator = (0, _kubb_core.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
 			})
@@ -841,7 +1101,7 @@ const pluginTs = (0, _kubb_core.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: {
@@ -859,7 +1119,6 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 			syntaxType,
 			group,
 			override,
-			mapper,
 			paramsCasing,
 			usedEnumNames: {}
 		},
@@ -944,6 +1203,13 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 						await Promise.all(writeTasks);
 					}
 				}, { depth: "shallow" });
+				const barrelFiles = await (0, _kubb_core.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();
@@ -1010,4 +1276,4 @@ Object.defineProperty(exports, "typeGenerator$1", {
 	}
 });
 
-//# sourceMappingURL=plugin-DvK-Uhvv.cjs.map
+//# sourceMappingURL=plugin-BrQcApyO.cjs.map