@kubb/plugin-ts 5.0.0-alpha.11 → 5.0.0-alpha.12

package/dist/plugin-D60XNJSD.js

@@ -1,1267 +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-CRu8IKY3.js";
-import path from "node:path";
-import { applyParamsCasing, collect, createProperty, createSchema, isPlainStringType, walk } from "@kubb/ast";
-import { createPlugin, defineGenerator, definePrinter, defineResolver, getBarrelFiles, getMode, renderOperation, renderSchema } from "@kubb/core";
-import { OperationGenerator, SchemaGenerator, isKeyword, pluginOasName, schemaKeywords } from "@kubb/plugin-oas";
-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";
-import { applyParamsCasing as applyParamsCasing$1, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
-import { File } from "@kubb/react-fabric";
-import ts from "typescript";
-import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-//#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, driver }) {
-	const properties = {};
-	if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
-		return createTypeReferenceNode(createIdentifier(driver.resolveName({
-			name: res.name,
-			pluginName: pluginTsName,
-			type: "function"
-		})), void 0);
-	}) });
-	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(driver.resolveName({
-		name: schemas.pathParams.name,
-		pluginName: pluginTsName,
-		type: "function"
-	})), void 0);
-	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(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(driver.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, driver }) {
-	const name = driver.resolveName({
-		name: `${baseName} Request`,
-		pluginName: pluginTsName,
-		type: "type"
-	});
-	const results = [];
-	const dataRequestProperties = [];
-	if (schemas.request) {
-		const identifier = driver.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 = driver.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 = driver.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 = driver.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, driver, unknownType }) {
-	const results = [];
-	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 = driver.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",
-	Operation({ operation, generator, plugin }) {
-		const { options, options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
-		const mode = useMode();
-		const driver = usePluginDriver();
-		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,
-			driver,
-			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$1(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,
-				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: driver.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,
-					driver
-				})
-			}), /* @__PURE__ */ jsx(File.Source, {
-				name: responseName,
-				isExportable: true,
-				isIndexable: true,
-				isTypeOnly: true,
-				children: printResponseSchema({
-					baseName: name,
-					schemas,
-					driver,
-					unknownType
-				})
-			})] }) : /* @__PURE__ */ jsx(File.Source, {
-				name: combinedSchemaName,
-				isExportable: true,
-				isIndexable: true,
-				isTypeOnly: true,
-				children: printCombinedSchema({
-					name: combinedSchemaName,
-					schemas,
-					driver
-				})
-			})]
-		});
-	},
-	Schema({ schema, plugin }) {
-		const { options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
-		const mode = useMode();
-		const oas = useOas();
-		const driver = usePluginDriver();
-		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: driver.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,
-				enumType,
-				enumKeyCasing,
-				optionalType,
-				arrayType,
-				syntaxType
-			})]
-		});
-	}
-});
-//#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") {
-		if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
-		return createLiteralTypeNode(createNumericLiteral(value));
-	}
-	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;
-	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);
-}
-/**
-* Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
-*/
-function buildPropertyType(schema, baseType, 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,
-		"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
-	];
-}
-/**
-* 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) {
-		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;
-}
-/**
-* 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.
-*
-* @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) => {
-	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" || m.primitive === "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)
-					});
-				});
-				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
-				]
-			});
-		}
-	};
-});
-//#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, description }) {
-	const resolvedDescription = description || node?.description;
-	const enumSchemaNodes = collect(node, { schema(n) {
-		if (n.type === "enum" && n.name) return n;
-	} });
-	const typeNode = printerTs({
-		optionalType,
-		arrayType,
-		enumType,
-		typeName: name,
-		syntaxType,
-		description: resolvedDescription,
-		keysToOmit
-	}).print(node);
-	if (!typeNode) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			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(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enumType,
-		enumKeyCasing
-	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-		name: typedName,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: safePrint(typeNode)
-	})] });
-}
-//#endregion
-//#region src/resolverTs.ts
-/**
-* Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
-* helpers used by the plugin. Import this in other plugins to resolve the exact names and
-* paths that `plugin-ts` generates without hardcoding the conventions.
-*
-* The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
-* for identifiers/files and `pascalCase` for type names.
-*
-* @example
-* ```ts
-* import { resolver } from '@kubb/plugin-ts'
-*
-* resolver.default('list pets', 'type')              // → 'ListPets'
-* resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
-* resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
-* resolver.resolvePathName('list pets', 'file')       // → 'listPets'
-* ```
-*/
-const resolverTs = defineResolver(() => {
-	return {
-		default(name, type) {
-			return pascalCase(name, { isFile: type === "file" });
-		},
-		resolveName(name) {
-			return this.default(name, "function");
-		},
-		resolveTypedName(name) {
-			return this.default(name, "type");
-		},
-		resolvePathName(name, type) {
-			return this.default(name, type);
-		},
-		resolveParamName(node, param) {
-			return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-		},
-		resolveParamTypedName(node, param) {
-			return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-		},
-		resolveResponseStatusName(node, statusCode) {
-			return this.resolveName(`${node.operationId} Status ${statusCode}`);
-		},
-		resolveResponseStatusTypedName(node, statusCode) {
-			return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
-		},
-		resolveDataName(node) {
-			return this.resolveName(`${node.operationId} Data`);
-		},
-		resolveDataTypedName(node) {
-			return this.resolveTypedName(`${node.operationId} Data`);
-		},
-		resolveRequestConfigName(node) {
-			return this.resolveName(`${node.operationId} RequestConfig`);
-		},
-		resolveRequestConfigTypedName(node) {
-			return this.resolveTypedName(`${node.operationId} RequestConfig`);
-		},
-		resolveResponsesName(node) {
-			return this.resolveName(`${node.operationId} Responses`);
-		},
-		resolveResponsesTypedName(node) {
-			return this.resolveTypedName(`${node.operationId} Responses`);
-		},
-		resolveResponseName(node) {
-			return this.resolveName(`${node.operationId} Response`);
-		},
-		resolveResponseTypedName(node) {
-			return this.resolveTypedName(`${node.operationId} Response`);
-		},
-		resolveEnumKeyTypedName(node) {
-			return `${this.resolveTypedName(node.name ?? "")}Key`;
-		}
-	};
-});
-//#endregion
-//#region src/generators/v2/utils.ts
-/**
-* Builds an `ObjectSchemaNode` for a group of parameters (path/query/header).
-* Each property is a `ref` schema pointing to the individually-resolved parameter type.
-* The ref name includes the parameter location so generated type names follow
-* the `<OperationId><Location><ParamName>` convention.
-*/
-function buildParamsSchema({ params, operationId, resolveName }) {
-	return createSchema({
-		type: "object",
-		properties: params.map((param) => createProperty({
-			name: param.name,
-			schema: createSchema({
-				type: "ref",
-				name: resolveName({
-					name: `${operationId} ${pascalCase(param.in)} ${param.name}`,
-					type: "function"
-				}),
-				optional: !param.required
-			})
-		}))
-	});
-}
-/**
-* Builds an `ObjectSchemaNode` representing the `<OperationId>RequestConfig` type:
-* - `data`         → request body ref (optional) or `never`
-* - `pathParams`   → inline object of path param refs, or `never`
-* - `queryParams`  → inline object of query param refs (optional), or `never`
-* - `headerParams` → inline object of header param refs (optional), or `never`
-* - `url`          → Express-style template literal (plugin-ts extension, handled by printer)
-*/
-function buildDataSchemaNode({ node, resolveName }) {
-	const pathParams = node.parameters.filter((p) => p.in === "path");
-	const queryParams = node.parameters.filter((p) => p.in === "query");
-	const headerParams = node.parameters.filter((p) => p.in === "header");
-	return createSchema({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			createProperty({
-				name: "data",
-				schema: node.requestBody ? createSchema({
-					type: "ref",
-					name: resolveName({
-						name: `${node.operationId} Data`,
-						type: "function"
-					}),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "pathParams",
-				schema: pathParams.length > 0 ? buildParamsSchema({
-					params: pathParams,
-					operationId: node.operationId,
-					resolveName
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "queryParams",
-				schema: queryParams.length > 0 ? createSchema({
-					...buildParamsSchema({
-						params: queryParams,
-						operationId: node.operationId,
-						resolveName
-					}),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "headerParams",
-				schema: headerParams.length > 0 ? createSchema({
-					...buildParamsSchema({
-						params: headerParams,
-						operationId: node.operationId,
-						resolveName
-					}),
-					optional: true
-				}) : createSchema({
-					type: "never",
-					optional: true
-				})
-			}),
-			createProperty({
-				name: "url",
-				schema: createSchema({
-					type: "url",
-					path: node.path
-				})
-			})
-		]
-	});
-}
-/**
-* Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
-* Numeric status codes produce unquoted numeric keys (e.g. `200:`).
-* All responses are included; those without a schema are represented as a ref to a `never` type.
-*/
-function buildResponsesSchemaNode({ node, resolveName }) {
-	if (node.responses.length === 0) return null;
-	return createSchema({
-		type: "object",
-		properties: node.responses.map((res) => createProperty({
-			name: String(res.statusCode),
-			schema: createSchema({
-				type: "ref",
-				name: resolveName({
-					name: `${node.operationId} Status ${res.statusCode}`,
-					type: "function"
-				})
-			})
-		}))
-	});
-}
-/**
-* Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
-* Returns `null` when the operation has no responses with schemas.
-*/
-function buildResponseUnionSchemaNode({ node, resolveName }) {
-	const responsesWithSchema = node.responses.filter((res) => res.schema);
-	if (responsesWithSchema.length === 0) return null;
-	return createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => createSchema({
-			type: "ref",
-			name: resolveName({
-				name: `${node.operationId} Status ${res.statusCode}`,
-				type: "function"
-			})
-		}))
-	});
-}
-//#endregion
-//#region src/generators/v2/typeGenerator.tsx
-const typeGenerator = defineGenerator({
-	name: "typescript",
-	type: "react",
-	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
-		const { mode, getFile, resolveName, resolveBanner, resolveFooter } = useKubb();
-		const file = getFile({
-			name: node.operationId,
-			extname: ".ts",
-			mode,
-			options: { group: group ? group.type === "tag" ? { tag: node.tags[0] } : { path: node.path } : void 0 }
-		});
-		const params = applyParamsCasing(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
-			if (!schemaNode) return null;
-			const imports = adapter.getImports(schemaNode, (schemaName) => ({
-				name: resolveName({
-					name: schemaName,
-					type: "type"
-				}),
-				path: getFile({
-					name: schemaName,
-					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 = params.map((param) => renderSchemaType({
-			node: param.schema,
-			name: resolverTs.resolveParamName(node, param),
-			typedName: resolverTs.resolveParamTypedName(node, param)
-		}));
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			node: res.schema,
-			name: resolverTs.resolveResponseStatusName(node, res.statusCode),
-			typedName: resolverTs.resolveResponseStatusTypedName(node, res.statusCode),
-			description: res.description
-		}));
-		const requestType = node.requestBody ? renderSchemaType({
-			node: node.requestBody,
-			name: resolverTs.resolveDataName(node),
-			typedName: resolverTs.resolveDataTypedName(node),
-			description: node.requestBody.description
-		}) : null;
-		const dataType = renderSchemaType({
-			node: buildDataSchemaNode({
-				node: {
-					...node,
-					parameters: params
-				},
-				resolveName
-			}),
-			name: resolverTs.resolveRequestConfigName(node),
-			typedName: resolverTs.resolveRequestConfigTypedName(node)
-		});
-		const responsesType = renderSchemaType({
-			node: buildResponsesSchemaNode({
-				node,
-				resolveName
-			}),
-			name: resolverTs.resolveResponsesName(node),
-			typedName: resolverTs.resolveResponsesTypedName(node)
-		});
-		const responseType = renderSchemaType({
-			node: buildResponseUnionSchemaNode({
-				node,
-				resolveName
-			}),
-			name: resolverTs.resolveResponseName(node),
-			typedName: resolverTs.resolveResponseTypedName(node),
-			description: "Union of all possible responses"
-		});
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: resolveBanner(),
-			footer: resolveFooter(),
-			children: [
-				paramTypes,
-				responseTypes,
-				requestType,
-				dataType,
-				responsesType,
-				responseType
-			]
-		});
-	},
-	Schema({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-		const { mode, resolveName, getFile, resolveBanner, resolveFooter } = useKubb();
-		if (!node.name) return;
-		const imports = adapter.getImports(node, (schemaName) => ({
-			name: resolveName({
-				name: schemaName,
-				type: "type"
-			}),
-			path: getFile({
-				name: schemaName,
-				extname: ".ts",
-				mode
-			}).path
-		}));
-		const isEnumSchema = node.type === "enum";
-		const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolverTs.resolveEnumKeyTypedName(node) : resolverTs.resolveTypedName(node.name);
-		const type = {
-			name: resolverTs.resolveName(node.name),
-			typedName,
-			file: getFile({
-				name: node.name,
-				extname: ".ts",
-				mode
-			})
-		};
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolveBanner(),
-			footer: resolveFooter(),
-			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 = createPlugin((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 = {}, 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,
-			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 = resolverTs.default(name, type);
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		async install() {
-			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) {
-				await openInStudio({ ast: true });
-				await walk(rootNode, {
-					async schema(schemaNode) {
-						const writeTasks = generators.map(async (generator) => {
-							if (generator.type === "react" && generator.version === "2") {
-								const options = resolverTs.resolveOptions(schemaNode, {
-									options: plugin.options,
-									exclude,
-									include,
-									override
-								});
-								if (options === null) return;
-								await renderSchema(schemaNode, {
-									options,
-									adapter,
-									config,
-									fabric,
-									Component: generator.Schema,
-									plugin,
-									driver,
-									mode
-								});
-							}
-						});
-						await Promise.all(writeTasks);
-					},
-					async operation(operationNode) {
-						const writeTasks = generators.map(async (generator) => {
-							if (generator.type === "react" && generator.version === "2") {
-								const options = resolverTs.resolveOptions(operationNode, {
-									options: plugin.options,
-									exclude,
-									include,
-									override
-								});
-								if (options === null) return;
-								await renderOperation(operationNode, {
-									options,
-									adapter,
-									config,
-									fabric,
-									Component: generator.Operation,
-									plugin,
-									driver,
-									mode
-								});
-							}
-						});
-						await Promise.all(writeTasks);
-					}
-				}, { depth: "shallow" });
-				const barrelFiles = await getBarrelFiles(this.fabric.files, {
-					type: output.barrelType ?? "named",
-					root,
-					output,
-					meta: { pluginName: this.plugin.name }
-				});
-				await this.upsertFile(...barrelFiles);
-				return;
-			}
-			const oas = await this.getOas();
-			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				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,
-				driver: this.driver,
-				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 a, resolverTs as i, pluginTsName as n, typeGenerator as r, pluginTs as t };
-
-//# sourceMappingURL=plugin-D60XNJSD.js.map