@kubb/plugin-ts 5.0.0-alpha.5 → 5.0.0-alpha.7

package/dist/{plugin-kdQ5D2cW.js → plugin-DVhVzwDg.js}

@@ -1,10 +1,10 @@
 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-Cwn1rflQ.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 { 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 { useKubb, useMode, usePluginDriver } 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";
@@ -26,37 +26,37 @@ function stringify(value) {
 }
 //#endregion
 //#region src/generators/typeGenerator.tsx
-function printCombinedSchema({ name, schemas, pluginManager }) {
+function printCombinedSchema({ name, schemas, driver }) {
 	const properties = {};
 	if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
-		return createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		return createTypeReferenceNode(createIdentifier(driver.resolveName({
 			name: res.name,
 			pluginName: pluginTsName,
 			type: "function"
 		})), void 0);
 	}) });
-	if (schemas.request) properties["request"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+	if (schemas.request) properties["request"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
 		name: schemas.request.name,
 		pluginName: pluginTsName,
 		type: "function"
 	})), void 0);
-	if (schemas.pathParams) properties["pathParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+	if (schemas.pathParams) properties["pathParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
 		name: schemas.pathParams.name,
 		pluginName: pluginTsName,
 		type: "function"
 	})), void 0);
-	if (schemas.queryParams) properties["queryParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+	if (schemas.queryParams) properties["queryParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
 		name: schemas.queryParams.name,
 		pluginName: pluginTsName,
 		type: "function"
 	})), void 0);
-	if (schemas.headerParams) properties["headerParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+	if (schemas.headerParams) properties["headerParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
 		name: schemas.headerParams.name,
 		pluginName: pluginTsName,
 		type: "function"
 	})), void 0);
 	if (schemas.errors) properties["errors"] = createUnionDeclaration({ nodes: schemas.errors.map((error) => {
-		return createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		return createTypeReferenceNode(createIdentifier(driver.resolveName({
 			name: error.name,
 			pluginName: pluginTsName,
 			type: "function"
@@ -75,8 +75,8 @@ function printCombinedSchema({ name, schemas, pluginManager }) {
 		modifiers: [modifiers.export]
 	}));
 }
-function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
-	const name = pluginManager.resolveName({
+function printRequestSchema({ baseName, operation, schemas, driver }) {
+	const name = driver.resolveName({
 		name: `${baseName} Request`,
 		pluginName: pluginTsName,
 		type: "type"
@@ -84,7 +84,7 @@ function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
 	const results = [];
 	const dataRequestProperties = [];
 	if (schemas.request) {
-		const identifier = pluginManager.resolveName({
+		const identifier = driver.resolveName({
 			name: schemas.request.name,
 			pluginName: pluginTsName,
 			type: "type"
@@ -100,7 +100,7 @@ function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
 		type: keywordTypeNodes.never
 	}));
 	if (schemas.pathParams) {
-		const identifier = pluginManager.resolveName({
+		const identifier = driver.resolveName({
 			name: schemas.pathParams.name,
 			pluginName: pluginTsName,
 			type: "type"
@@ -115,7 +115,7 @@ function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
 		type: keywordTypeNodes.never
 	}));
 	if (schemas.queryParams) {
-		const identifier = pluginManager.resolveName({
+		const identifier = driver.resolveName({
 			name: schemas.queryParams.name,
 			pluginName: pluginTsName,
 			type: "type"
@@ -131,7 +131,7 @@ function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
 		type: keywordTypeNodes.never
 	}));
 	if (schemas.headerParams) {
-		const identifier = pluginManager.resolveName({
+		const identifier = driver.resolveName({
 			name: schemas.headerParams.name,
 			pluginName: pluginTsName,
 			type: "type"
@@ -158,16 +158,16 @@ function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
 	results.push(safePrint(dataRequestNode));
 	return results.join("\n\n");
 }
-function printResponseSchema({ baseName, schemas, pluginManager, unknownType }) {
+function printResponseSchema({ baseName, schemas, driver, unknownType }) {
 	const results = [];
-	const name = pluginManager.resolveName({
+	const name = driver.resolveName({
 		name: `${baseName} ResponseData`,
 		pluginName: pluginTsName,
 		type: "type"
 	});
 	if (schemas.responses && schemas.responses.length > 0) {
 		const responsesProperties = schemas.responses.map((res) => {
-			const identifier = pluginManager.resolveName({
+			const identifier = driver.resolveName({
 				name: res.name,
 				pluginName: pluginTsName,
 				type: "type"
@@ -202,9 +202,9 @@ 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 driver = usePluginDriver();
 		const oas = useOas();
 		const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator);
 		const schemaManager = useSchemaManager();
@@ -219,7 +219,7 @@ const typeGenerator$1 = createReactGenerator({
 			oas,
 			events: generator.context.events,
 			plugin,
-			pluginManager,
+			driver,
 			mode,
 			override: options.override
 		});
@@ -261,7 +261,6 @@ const typeGenerator$1 = createReactGenerator({
 				description,
 				tree,
 				schema: transformedSchema,
-				mapper,
 				enumType,
 				enumKeyCasing,
 				optionalType,
@@ -279,7 +278,7 @@ const typeGenerator$1 = createReactGenerator({
 			banner: getBanner({
 				oas,
 				output: plugin.options.output,
-				config: pluginManager.config
+				config: driver.config
 			}),
 			footer: getFooter({
 				oas,
@@ -294,7 +293,7 @@ const typeGenerator$1 = createReactGenerator({
 					baseName: name,
 					operation,
 					schemas,
-					pluginManager
+					driver
 				})
 			}), /* @__PURE__ */ jsx(File.Source, {
 				name: responseName,
@@ -304,7 +303,7 @@ const typeGenerator$1 = createReactGenerator({
 				children: printResponseSchema({
 					baseName: name,
 					schemas,
-					pluginManager,
+					driver,
 					unknownType
 				})
 			})] }) : /* @__PURE__ */ jsx(File.Source, {
@@ -315,16 +314,16 @@ const typeGenerator$1 = createReactGenerator({
 				children: printCombinedSchema({
 					name: combinedSchemaName,
 					schemas,
-					pluginManager
+					driver
 				})
 			})]
 		});
 	},
 	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();
+		const driver = usePluginDriver();
 		const { getName, getFile } = useSchemaManager();
 		const imports = getImports(schema.tree);
 		const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema);
@@ -342,7 +341,7 @@ const typeGenerator$1 = createReactGenerator({
 			banner: getBanner({
 				oas,
 				output,
-				config: pluginManager.config
+				config: driver.config
 			}),
 			footer: getFooter({
 				oas,
@@ -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,204 +492,238 @@ 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.
+*
+* 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.
 *
-* 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`.
+* @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,
-		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: (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) => {
-				if (this.options.mapper && Object.hasOwn(this.options.mapper, prop.name)) return this.options.mapper[prop.name];
-				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, mapper, ...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,
-		mapper
+		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
@@ -642,6 +731,8 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
 /**
 * 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({
@@ -651,7 +742,7 @@ function buildParamsSchema({ params, operationId, resolveName }) {
 			schema: createSchema({
 				type: "ref",
 				name: resolveName({
-					name: `${operationId} ${param.name}`,
+					name: `${operationId} ${pascalCase(param.in)} ${param.name}`,
 					type: "function"
 				}),
 				optional: !param.required
@@ -660,7 +751,7 @@ function buildParamsSchema({ params, operationId, resolveName }) {
 	});
 }
 /**
-* Builds an `ObjectSchemaNode` representing the `<OperationId>Data` type:
+* 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`
@@ -679,7 +770,7 @@ function buildDataSchemaNode({ node, resolveName }) {
 				schema: node.requestBody ? createSchema({
 					type: "ref",
 					name: resolveName({
-						name: `${node.operationId} MutationRequest`,
+						name: `${node.operationId} Data`,
 						type: "function"
 					}),
 					optional: true
@@ -739,11 +830,7 @@ function buildDataSchemaNode({ node, resolveName }) {
 }
 /**
 * Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
-*
-* Example output:
-* ```ts
-* export type PlaceOrderPatchResponses = { 200: PlaceOrderPatch200; 405: PlaceOrderPatch405 }
-* ```
+* Numeric status codes produce unquoted numeric keys (e.g. `200:`).
 */
 function buildResponsesSchemaNode({ node, resolveName }) {
 	const responsesWithSchema = node.responses.filter((res) => res.schema);
@@ -755,7 +842,7 @@ function buildResponsesSchemaNode({ node, resolveName }) {
 			schema: createSchema({
 				type: "ref",
 				name: resolveName({
-					name: `${node.operationId} ${res.statusCode}`,
+					name: `${node.operationId} Status ${res.statusCode}`,
 					type: "function"
 				})
 			})
@@ -764,11 +851,7 @@ function buildResponsesSchemaNode({ node, resolveName }) {
 }
 /**
 * Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
-*
-* Example output:
-* ```ts
-* export type PlaceOrderPatchResponse = PlaceOrderPatch200 | PlaceOrderPatch405
-* ```
+* Returns `null` when the operation has no responses with schemas.
 */
 function buildResponseUnionSchemaNode({ node, resolveName }) {
 	const responsesWithSchema = node.responses.filter((res) => res.schema);
@@ -778,7 +861,7 @@ function buildResponseUnionSchemaNode({ node, resolveName }) {
 		members: responsesWithSchema.map((res) => createSchema({
 			type: "ref",
 			name: resolveName({
-				name: `${node.operationId} ${res.statusCode}`,
+				name: `${node.operationId} Status ${res.statusCode}`,
 				type: "function"
 			})
 		}))
@@ -790,12 +873,13 @@ const typeGenerator = defineGenerator({
 	name: "typescript",
 	type: "react",
 	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, mapper } = options;
+		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
 		const { mode, getFile, resolveName } = useKubb();
 		const file = getFile({
 			name: node.operationId,
 			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 }) {
@@ -829,29 +913,28 @@ const typeGenerator = defineGenerator({
 				enumKeyCasing,
 				optionalType,
 				arrayType,
-				syntaxType,
-				mapper
+				syntaxType
 			})] });
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
 			node: param.schema,
 			name: resolveName({
-				name: `${node.operationId} ${param.name}`,
+				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
 				type: "function"
 			}),
 			typedName: resolveName({
-				name: `${node.operationId} ${param.name}`,
+				name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`,
 				type: "type"
 			})
 		}));
 		const responseTypes = node.responses.filter((res) => res.schema).map((res) => renderSchemaType({
 			node: res.schema,
 			name: resolveName({
-				name: `${node.operationId} ${res.statusCode}`,
+				name: `${node.operationId} Status ${res.statusCode}`,
 				type: "function"
 			}),
 			typedName: resolveName({
-				name: `${node.operationId} ${res.statusCode}`,
+				name: `${node.operationId} Status ${res.statusCode}`,
 				type: "type"
 			}),
 			description: res.description
@@ -859,11 +942,11 @@ const typeGenerator = defineGenerator({
 		const requestType = node.requestBody ? renderSchemaType({
 			node: node.requestBody,
 			name: resolveName({
-				name: `${node.operationId} MutationRequest`,
+				name: `${node.operationId} Data`,
 				type: "function"
 			}),
 			typedName: resolveName({
-				name: `${node.operationId} MutationRequest`,
+				name: `${node.operationId} Data`,
 				type: "type"
 			}),
 			description: node.requestBody.description
@@ -877,11 +960,11 @@ const typeGenerator = defineGenerator({
 				resolveName
 			}),
 			name: resolveName({
-				name: `${node.operationId} Data`,
+				name: `${node.operationId} RequestConfig`,
 				type: "function"
 			}),
 			typedName: resolveName({
-				name: `${node.operationId} Data`,
+				name: `${node.operationId} RequestConfig`,
 				type: "type"
 			})
 		});
@@ -911,7 +994,8 @@ const typeGenerator = defineGenerator({
 			typedName: resolveName({
 				name: `${node.operationId} Response`,
 				type: "type"
-			})
+			}),
+			description: "Union of all possible responses"
 		});
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: file.baseName,
@@ -928,7 +1012,7 @@ const typeGenerator = defineGenerator({
 		});
 	},
 	Schema({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, mapper } = options;
+		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
 		const { mode, resolveName, getFile } = useKubb();
 		if (!node.name) return;
 		const imports = adapter.getImports(node, (schemaName) => ({
@@ -947,7 +1031,7 @@ const typeGenerator = defineGenerator({
 			name: node.name,
 			type: "type"
 		});
-		if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName += "Key";
+		if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema) typedName += "Key";
 		const type = {
 			name: resolveName({
 				name: node.name,
@@ -981,8 +1065,7 @@ const typeGenerator = defineGenerator({
 				enumKeyCasing,
 				optionalType,
 				arrayType,
-				syntaxType,
-				mapper
+				syntaxType
 			})]
 		});
 	}
@@ -994,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: {
@@ -1012,7 +1095,6 @@ const pluginTs = definePlugin((options) => {
 			syntaxType,
 			group,
 			override,
-			mapper,
 			paramsCasing,
 			usedEnumNames: {}
 		},
@@ -1040,7 +1122,7 @@ const pluginTs = definePlugin((options) => {
 			return resolvedName;
 		},
 		async install() {
-			const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this;
+			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this;
 			const root = path.resolve(config.root, config.output.path);
 			const mode = getMode(path.resolve(root, output.path));
 			if (adapter) {
@@ -1063,7 +1145,7 @@ const pluginTs = definePlugin((options) => {
 									fabric,
 									Component: generator.Schema,
 									plugin,
-									pluginManager,
+									driver,
 									mode,
 									version: generator.version
 								});
@@ -1088,7 +1170,7 @@ const pluginTs = definePlugin((options) => {
 									fabric,
 									Component: generator.Operation,
 									plugin,
-									pluginManager,
+									driver,
 									mode,
 									version: generator.version
 								});
@@ -1110,7 +1192,7 @@ const pluginTs = definePlugin((options) => {
 			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
 				fabric: this.fabric,
 				oas,
-				pluginManager: this.pluginManager,
+				driver: this.driver,
 				events: this.events,
 				plugin: this.plugin,
 				contentType,
@@ -1123,7 +1205,7 @@ const pluginTs = definePlugin((options) => {
 			const operationFiles = await new OperationGenerator(this.plugin.options, {
 				fabric: this.fabric,
 				oas,
-				pluginManager: this.pluginManager,
+				driver: this.driver,
 				events: this.events,
 				plugin: this.plugin,
 				contentType,
@@ -1147,4 +1229,4 @@ const pluginTs = definePlugin((options) => {
 //#endregion
 export { typeGenerator$1 as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
 
-//# sourceMappingURL=plugin-kdQ5D2cW.js.map
+//# sourceMappingURL=plugin-DVhVzwDg.js.map