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

package/dist/plugin-DmwgRHK8.js

@@ -1,944 +0,0 @@
-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