@kubb/plugin-ts 5.0.0-alpha.1 → 5.0.0-alpha.3

package/dist/plugin-DmwgRHK8.js

@@ -0,0 +1,944 @@
+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 path from "node:path";
+import { collect, isPlainStringType, walk } from "@kubb/ast";
+import { definePlugin, definePrinter, getBarrelFiles, getMode } 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 { File } from "@kubb/react-fabric";
+import ts from "typescript";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region ../../internals/utils/src/object.ts
+/**
+* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+*
+* @example
+* stringify('hello')   // '"hello"'
+* stringify('"hello"') // '"hello"'
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "\"\"";
+	return JSON.stringify(trimQuotes(value.toString()));
+}
+//#endregion
+//#region src/generators/typeGenerator.tsx
+function printCombinedSchema({ name, schemas, pluginManager }) {
+	const properties = {};
+	if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
+		return createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+			name: res.name,
+			pluginName: pluginTsName,
+			type: "function"
+		})), void 0);
+	}) });
+	if (schemas.request) properties["request"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.request.name,
+		pluginName: pluginTsName,
+		type: "function"
+	})), void 0);
+	if (schemas.pathParams) properties["pathParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.pathParams.name,
+		pluginName: pluginTsName,
+		type: "function"
+	})), void 0);
+	if (schemas.queryParams) properties["queryParams"] = createTypeReferenceNode(createIdentifier(pluginManager.resolveName({
+		name: schemas.queryParams.name,
+		pluginName: pluginTsName,
+		type: "function"
+	})), void 0);
+	if (schemas.headerParams) properties["headerParams"] = createTypeReferenceNode(createIdentifier(pluginManager.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({
+			name: error.name,
+			pluginName: pluginTsName,
+			type: "function"
+		})), void 0);
+	}) });
+	return safePrint(createTypeAliasDeclaration({
+		name,
+		type: createTypeLiteralNode(Object.keys(properties).map((key) => {
+			const type = properties[key];
+			if (!type) return;
+			return createPropertySignature({
+				name: pascalCase(key),
+				type
+			});
+		}).filter(Boolean)),
+		modifiers: [modifiers.export]
+	}));
+}
+function printRequestSchema({ baseName, operation, schemas, pluginManager }) {
+	const name = pluginManager.resolveName({
+		name: `${baseName} Request`,
+		pluginName: pluginTsName,
+		type: "type"
+	});
+	const results = [];
+	const dataRequestProperties = [];
+	if (schemas.request) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.request.name,
+			pluginName: pluginTsName,
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "data",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "data",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.pathParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.pathParams.name,
+			pluginName: pluginTsName,
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "pathParams",
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "pathParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.queryParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.queryParams.name,
+			pluginName: pluginTsName,
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "queryParams",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "queryParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	if (schemas.headerParams) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.headerParams.name,
+			pluginName: pluginTsName,
+			type: "type"
+		});
+		dataRequestProperties.push(createPropertySignature({
+			name: "headerParams",
+			questionToken: true,
+			type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+		}));
+	} else dataRequestProperties.push(createPropertySignature({
+		name: "headerParams",
+		questionToken: true,
+		type: keywordTypeNodes.never
+	}));
+	dataRequestProperties.push(createPropertySignature({
+		name: "url",
+		type: createUrlTemplateType(operation.path)
+	}));
+	const dataRequestNode = createTypeAliasDeclaration({
+		name,
+		type: createTypeLiteralNode(dataRequestProperties),
+		modifiers: [modifiers.export]
+	});
+	results.push(safePrint(dataRequestNode));
+	return results.join("\n\n");
+}
+function printResponseSchema({ baseName, schemas, pluginManager, unknownType }) {
+	const results = [];
+	const name = pluginManager.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({
+				name: res.name,
+				pluginName: pluginTsName,
+				type: "type"
+			});
+			return createPropertySignature({
+				name: res.statusCode?.toString() ?? "default",
+				type: createTypeReferenceNode(createIdentifier(identifier), void 0)
+			});
+		});
+		const responsesNode = createTypeAliasDeclaration({
+			name: `${baseName}Responses`,
+			type: createTypeLiteralNode(responsesProperties),
+			modifiers: [modifiers.export]
+		});
+		results.push(safePrint(responsesNode));
+		const responseNode = createTypeAliasDeclaration({
+			name,
+			type: createIndexedAccessTypeNode(createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0), createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0))),
+			modifiers: [modifiers.export]
+		});
+		results.push(safePrint(responseNode));
+	} else {
+		const responseNode = createTypeAliasDeclaration({
+			name,
+			modifiers: [modifiers.export],
+			type: getUnknownType(unknownType)
+		});
+		results.push(safePrint(responseNode));
+	}
+	return results.join("\n\n");
+}
+const typeGenerator$1 = createReactGenerator({
+	name: "typescript",
+	version: "1",
+	Operation({ operation, generator, plugin }) {
+		const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
+		const mode = useMode();
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator);
+		const schemaManager = useSchemaManager();
+		const name = getName(operation, {
+			type: "type",
+			pluginName: pluginTsName
+		});
+		const file = getFile(operation);
+		const schemas = getSchemas(operation);
+		const schemaGenerator = new SchemaGenerator(options, {
+			fabric: generator.context.fabric,
+			oas,
+			events: generator.context.events,
+			plugin,
+			pluginManager,
+			mode,
+			override: options.override
+		});
+		const operationSchemas = [
+			schemas.pathParams,
+			schemas.queryParams,
+			schemas.headerParams,
+			schemas.statusCodes,
+			schemas.request,
+			schemas.response
+		].flat().filter(Boolean);
+		const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }) => {
+			const transformedSchema = paramsCasing && isParameterSchema(name) ? applyParamsCasing(schema, paramsCasing) : schema;
+			const tree = schemaGenerator.parse({
+				schema: transformedSchema,
+				name,
+				parentName: null
+			});
+			const imports = getImports(tree);
+			const group = options.operation ? getGroup(options.operation) : void 0;
+			const type = {
+				name: schemaManager.getName(name, { type: "type" }),
+				typedName: schemaManager.getName(name, { type: "type" }),
+				file: schemaManager.getFile(options.operationName || name, { group })
+			};
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				name,
+				imp.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type$1, {
+				name: type.name,
+				typedName: type.typedName,
+				description,
+				tree,
+				schema: transformedSchema,
+				mapper,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				keysToOmit,
+				syntaxType
+			})] });
+		};
+		const responseName = schemaManager.getName(schemas.response.name, { type: "type" });
+		const combinedSchemaName = operation.method === "get" ? `${name}Query` : `${name}Mutation`;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output: plugin.options.output
+			}),
+			children: [operationSchemas.map(mapOperationSchema), generator.context.UNSTABLE_NAMING ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+				name: `${name}Request`,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printRequestSchema({
+					baseName: name,
+					operation,
+					schemas,
+					pluginManager
+				})
+			}), /* @__PURE__ */ jsx(File.Source, {
+				name: responseName,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printResponseSchema({
+					baseName: name,
+					schemas,
+					pluginManager,
+					unknownType
+				})
+			})] }) : /* @__PURE__ */ jsx(File.Source, {
+				name: combinedSchemaName,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: printCombinedSchema({
+					name: combinedSchemaName,
+					schemas,
+					pluginManager
+				})
+			})]
+		});
+	},
+	Schema({ schema, plugin }) {
+		const { options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
+		const mode = useMode();
+		const oas = useOas();
+		const pluginManager = usePluginManager();
+		const { getName, getFile } = useSchemaManager();
+		const imports = getImports(schema.tree);
+		const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema);
+		let typedName = getName(schema.name, { type: "type" });
+		if (["asConst", "asPascalConst"].includes(enumType) && schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.enum)) typedName = typedName += "Key";
+		const type = {
+			name: getName(schema.name, { type: "function" }),
+			typedName,
+			file: getFile(schema.name)
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: type.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				schema.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type$1, {
+				name: type.name,
+				typedName: type.typedName,
+				description: schema.value.description,
+				tree: schema.tree,
+				schema: schema.value,
+				mapper,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/printer.ts
+function constToTypeNode(value, format) {
+	if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
+	if (format === "number" && typeof value === "number") {
+		if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
+		return createLiteralTypeNode(createNumericLiteral(value));
+	}
+	return createLiteralTypeNode(createStringLiteral(String(value)));
+}
+function dateOrStringNode(node) {
+	return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
+}
+function buildMemberNodes(members, print) {
+	return (members ?? []).map(print).filter(Boolean);
+}
+function buildTupleNode(node, print) {
+	let items = (node.items ?? []).map(print).filter(Boolean);
+	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
+	const { min, max } = node;
+	if (max !== void 0) {
+		items = items.slice(0, max);
+		if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
+	}
+	if (min !== void 0) items = items.map((item, i) => i >= min ? createOptionalTypeNode(item) : item);
+	if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
+	return createTupleTypeNode(items);
+}
+function buildPropertyType(schema, baseType, optionalType) {
+	const addsUndefined = ["undefined", "questionTokenAndUndefined"].includes(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;
+}
+function buildPropertyJSDocComments(schema) {
+	return [
+		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
+		"deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+		"min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+		"max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
+		"pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+		"default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify(schema.default) : schema.default}` : void 0,
+		"example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
+		"primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+	];
+}
+function buildIndexSignatures(node, propertyCount, print) {
+	const elements = [];
+	if (node.additionalProperties && node.additionalProperties !== true) {
+		const additionalType = print(node.additionalProperties) ?? keywordTypeNodes.unknown;
+		elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
+	} else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
+	if (node.patternProperties) {
+		const first = Object.values(node.patternProperties)[0];
+		if (first) {
+			let patternType = print(first) ?? keywordTypeNodes.unknown;
+			if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
+			elements.push(createIndexSignature(patternType));
+		}
+	}
+	return elements;
+}
+/**
+* Converts a `SchemaNode` AST node into a TypeScript `ts.TypeNode`.
+*
+* 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`.
+*/
+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
+					});
+					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);
+		}
+	}
+}));
+//#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;
+	const enumSchemaNodes = collect(node, { schema(n) {
+		if (n.type === "enum" && n.name) return n;
+	} });
+	let type = printerTs({
+		optionalType,
+		arrayType,
+		enumType
+	}).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
+		});
+		return {
+			nameNode,
+			typeNode,
+			name: enumName,
+			typeName
+		};
+	});
+	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, {
+		name: typedName,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: safePrint(...typeNodes)
+	})] });
+}
+//#endregion
+//#region src/generators/v2/typeGenerator.tsx
+const typeGenerator = createReactGenerator({
+	name: "typescript",
+	version: "2",
+	Operation({ node, adapter, options }) {
+		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
+		const { plugin, mode, getFile, resolveName } = useKubb();
+		const file = getFile({
+			name: node.operationId,
+			pluginName: plugin.name,
+			extname: ".ts",
+			mode
+		});
+		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+			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
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name,
+				typedName,
+				node: schemaNode,
+				description,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType
+			})] });
+		}
+		const paramTypes = node.parameters.map((param) => {
+			const name = resolveName({
+				name: `${node.operationId} ${param.name}`,
+				pluginName: plugin.name,
+				type: "function"
+			});
+			const typedName = resolveName({
+				name: `${node.operationId} ${param.name}`,
+				pluginName: plugin.name,
+				type: "type"
+			});
+			return renderSchemaType({
+				node: param.schema,
+				name,
+				typedName
+			});
+		});
+		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 requestType = node.requestBody ? (() => {
+			const requestName = `${node.operationId} MutationRequest`;
+			const resolvedName = resolveName({
+				name: requestName,
+				pluginName: plugin.name,
+				type: "function"
+			});
+			const typedName = resolveName({
+				name: requestName,
+				pluginName: plugin.name,
+				type: "type"
+			});
+			return renderSchemaType({
+				node: node.requestBody,
+				name: resolvedName,
+				typedName,
+				description: node.requestBody.description
+			});
+		})() : null;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			children: [
+				paramTypes,
+				responseTypes,
+				requestType
+			]
+		});
+	},
+	Schema({ node, adapter, options }) {
+		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
+		const { plugin, 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
+		}));
+		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";
+		const type = {
+			name: resolveName({
+				name: node.name,
+				pluginName: plugin.name,
+				type: "function"
+			}),
+			typedName,
+			file: getFile({
+				name: node.name,
+				pluginName: plugin.name,
+				extname: ".ts",
+				mode
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: type.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				node.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: type.name,
+				typedName: type.typedName,
+				node,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/plugin.ts
+const pluginTsName = "plugin-ts";
+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;
+	return {
+		name: pluginTsName,
+		options: {
+			output,
+			transformers,
+			dateType,
+			integerType,
+			optionalType,
+			arrayType,
+			enumType,
+			enumKeyCasing,
+			enumSuffix,
+			unknownType,
+			emptySchemaType,
+			syntaxType,
+			group,
+			override,
+			mapper,
+			paramsCasing,
+			usedEnumNames: {}
+		},
+		pre: [pluginOasName],
+		resolvePath(baseName, pathMode, options) {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
+ /**
+			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
+			*/
+			return path.resolve(root, output.path);
+			if (group && (options?.group?.path || options?.group?.tag)) {
+				const groupName = group?.name ? group.name : (ctx) => {
+					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
+					return `${camelCase(ctx.group)}Controller`;
+				};
+				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			}
+			return path.resolve(root, output.path, baseName);
+		},
+		resolveName(name, type) {
+			const resolvedName = pascalCase(name, { isFile: type === "file" });
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this;
+			const root = path.resolve(config.root, config.output.path);
+			const mode = getMode(path.resolve(root, output.path));
+			if (adapter) {
+				await openInStudio({ ast: true });
+				await walk(rootNode, {
+					async schema(schemaNode) {
+						await generators.map(async (generator) => {
+							if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
+								adapter,
+								config,
+								fabric,
+								Component: generator.Schema,
+								plugin,
+								pluginManager,
+								mode,
+								version: generator.version
+							});
+						});
+					},
+					async operation(operationNode) {
+						await generators.map(async (generator) => {
+							if (generator.type === "react" && generator.version === "2") await buildOperation(operationNode, {
+								adapter,
+								config,
+								fabric,
+								Component: generator.Operation,
+								plugin,
+								pluginManager,
+								mode,
+								version: generator.version
+							});
+						});
+					}
+				}, { depth: "shallow" });
+				return;
+			}
+			const oas = await this.getOas();
+			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				include: void 0,
+				override,
+				mode,
+				output: output.path
+			}).build(...generators);
+			await this.upsertFile(...schemaFiles);
+			const operationFiles = await new OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode,
+				UNSTABLE_NAMING
+			}).build(...generators);
+			await this.upsertFile(...operationFiles);
+			const barrelFiles = await getBarrelFiles(this.fabric.files, {
+				type: output.barrelType ?? "named",
+				root,
+				output,
+				meta: { pluginName: this.plugin.name }
+			});
+			await this.upsertFile(...barrelFiles);
+		}
+	};
+});
+//#endregion
+export { typeGenerator$1 as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
+
+//# sourceMappingURL=plugin-DmwgRHK8.js.map