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

package/dist/plugin-CJ29AwE2.cjs

@@ -1,1320 +0,0 @@
-const require_components = require("./components-DeNDKlzf.cjs");
-let node_path = require("node:path");
-node_path = require_components.__toESM(node_path);
-let _kubb_ast = require("@kubb/ast");
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_oas = require("@kubb/plugin-oas");
-let _kubb_core_hooks = require("@kubb/core/hooks");
-let _kubb_fabric_core_parsers_typescript = require("@kubb/fabric-core/parsers/typescript");
-let _kubb_plugin_oas_generators = require("@kubb/plugin-oas/generators");
-let _kubb_plugin_oas_hooks = require("@kubb/plugin-oas/hooks");
-let _kubb_plugin_oas_utils = require("@kubb/plugin-oas/utils");
-let _kubb_react_fabric = require("@kubb/react-fabric");
-let typescript = require("typescript");
-typescript = require_components.__toESM(typescript);
-let _kubb_react_fabric_jsx_runtime = require("@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(require_components.trimQuotes(value.toString()));
-}
-//#endregion
-//#region src/generators/typeGenerator.tsx
-function printCombinedSchema({ name, schemas, driver }) {
-	const properties = {};
-	if (schemas.response) properties["response"] = require_components.createUnionDeclaration({ nodes: schemas.responses.map((res) => {
-		const identifier = driver.resolveName({
-			name: res.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		return require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}) });
-	if (schemas.request) {
-		const identifier = driver.resolveName({
-			name: schemas.request.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		properties["request"] = require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}
-	if (schemas.pathParams) {
-		const identifier = driver.resolveName({
-			name: schemas.pathParams.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		properties["pathParams"] = require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}
-	if (schemas.queryParams) {
-		const identifier = driver.resolveName({
-			name: schemas.queryParams.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		properties["queryParams"] = require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}
-	if (schemas.headerParams) {
-		const identifier = driver.resolveName({
-			name: schemas.headerParams.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		properties["headerParams"] = require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}
-	if (schemas.errors) properties["errors"] = require_components.createUnionDeclaration({ nodes: schemas.errors.map((error) => {
-		const identifier = driver.resolveName({
-			name: error.name,
-			pluginName: pluginTsName,
-			type: "function"
-		});
-		return require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
-	}) });
-	return (0, _kubb_fabric_core_parsers_typescript.safePrint)(require_components.createTypeAliasDeclaration({
-		name,
-		type: require_components.createTypeLiteralNode(Object.keys(properties).map((key) => {
-			const type = properties[key];
-			if (!type) return;
-			return require_components.createPropertySignature({
-				name: require_components.pascalCase(key),
-				type
-			});
-		}).filter(Boolean)),
-		modifiers: [require_components.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(require_components.createPropertySignature({
-			name: "data",
-			questionToken: true,
-			type: require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0)
-		}));
-	} else dataRequestProperties.push(require_components.createPropertySignature({
-		name: "data",
-		questionToken: true,
-		type: require_components.keywordTypeNodes.never
-	}));
-	if (schemas.pathParams) {
-		const identifier = driver.resolveName({
-			name: schemas.pathParams.name,
-			pluginName: pluginTsName,
-			type: "type"
-		});
-		dataRequestProperties.push(require_components.createPropertySignature({
-			name: "pathParams",
-			type: require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0)
-		}));
-	} else dataRequestProperties.push(require_components.createPropertySignature({
-		name: "pathParams",
-		questionToken: true,
-		type: require_components.keywordTypeNodes.never
-	}));
-	if (schemas.queryParams) {
-		const identifier = driver.resolveName({
-			name: schemas.queryParams.name,
-			pluginName: pluginTsName,
-			type: "type"
-		});
-		dataRequestProperties.push(require_components.createPropertySignature({
-			name: "queryParams",
-			questionToken: true,
-			type: require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0)
-		}));
-	} else dataRequestProperties.push(require_components.createPropertySignature({
-		name: "queryParams",
-		questionToken: true,
-		type: require_components.keywordTypeNodes.never
-	}));
-	if (schemas.headerParams) {
-		const identifier = driver.resolveName({
-			name: schemas.headerParams.name,
-			pluginName: pluginTsName,
-			type: "type"
-		});
-		dataRequestProperties.push(require_components.createPropertySignature({
-			name: "headerParams",
-			questionToken: true,
-			type: require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0)
-		}));
-	} else dataRequestProperties.push(require_components.createPropertySignature({
-		name: "headerParams",
-		questionToken: true,
-		type: require_components.keywordTypeNodes.never
-	}));
-	dataRequestProperties.push(require_components.createPropertySignature({
-		name: "url",
-		type: require_components.createUrlTemplateType(operation.path)
-	}));
-	const dataRequestNode = require_components.createTypeAliasDeclaration({
-		name,
-		type: require_components.createTypeLiteralNode(dataRequestProperties),
-		modifiers: [require_components.modifiers.export]
-	});
-	results.push((0, _kubb_fabric_core_parsers_typescript.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 require_components.createPropertySignature({
-				name: res.statusCode?.toString() ?? "default",
-				type: require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0)
-			});
-		});
-		const responsesNode = require_components.createTypeAliasDeclaration({
-			name: `${baseName}Responses`,
-			type: require_components.createTypeLiteralNode(responsesProperties),
-			modifiers: [require_components.modifiers.export]
-		});
-		results.push((0, _kubb_fabric_core_parsers_typescript.safePrint)(responsesNode));
-		const responseNode = require_components.createTypeAliasDeclaration({
-			name,
-			type: require_components.createIndexedAccessTypeNode(require_components.createTypeReferenceNode(require_components.createIdentifier(`${baseName}Responses`), void 0), require_components.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, require_components.createTypeReferenceNode(require_components.createIdentifier(`${baseName}Responses`), void 0))),
-			modifiers: [require_components.modifiers.export]
-		});
-		results.push((0, _kubb_fabric_core_parsers_typescript.safePrint)(responseNode));
-	} else {
-		const responseNode = require_components.createTypeAliasDeclaration({
-			name,
-			modifiers: [require_components.modifiers.export],
-			type: require_components.getUnknownType(unknownType)
-		});
-		results.push((0, _kubb_fabric_core_parsers_typescript.safePrint)(responseNode));
-	}
-	return results.join("\n\n");
-}
-const typeGenerator$1 = (0, _kubb_plugin_oas_generators.createReactGenerator)({
-	name: "typescript",
-	Operation({ operation, generator, plugin }) {
-		const { options, options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
-		const mode = (0, _kubb_core_hooks.useMode)();
-		const driver = (0, _kubb_core_hooks.usePluginDriver)();
-		const oas = (0, _kubb_plugin_oas_hooks.useOas)();
-		const { getSchemas, getFile, getName, getGroup } = (0, _kubb_plugin_oas_hooks.useOperationManager)(generator);
-		const schemaManager = (0, _kubb_plugin_oas_hooks.useSchemaManager)();
-		const name = getName(operation, {
-			type: "type",
-			pluginName: pluginTsName
-		});
-		const file = getFile(operation);
-		const schemas = getSchemas(operation);
-		const schemaGenerator = new _kubb_plugin_oas.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 && (0, _kubb_plugin_oas_utils.isParameterSchema)(name) ? (0, _kubb_plugin_oas_utils.applyParamsCasing)(schema, paramsCasing) : schema;
-			const tree = schemaGenerator.parse({
-				schema: transformedSchema,
-				name,
-				parentName: null
-			});
-			const imports = (0, _kubb_plugin_oas_utils.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
-				root: file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				name,
-				imp.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(require_components.Type, {
-				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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: (0, _kubb_plugin_oas_utils.getBanner)({
-				oas,
-				output: plugin.options.output,
-				config: driver.config
-			}),
-			footer: (0, _kubb_plugin_oas_utils.getFooter)({
-				oas,
-				output: plugin.options.output
-			}),
-			children: [operationSchemas.map(mapOperationSchema), generator.context.UNSTABLE_NAMING ? /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-				name: `${name}Request`,
-				isExportable: true,
-				isIndexable: true,
-				isTypeOnly: true,
-				children: printRequestSchema({
-					baseName: name,
-					operation,
-					schemas,
-					driver
-				})
-			}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-				name: responseName,
-				isExportable: true,
-				isIndexable: true,
-				isTypeOnly: true,
-				children: printResponseSchema({
-					baseName: name,
-					schemas,
-					driver,
-					unknownType
-				})
-			})] }) : /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.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 = (0, _kubb_core_hooks.useMode)();
-		const oas = (0, _kubb_plugin_oas_hooks.useOas)();
-		const driver = (0, _kubb_core_hooks.usePluginDriver)();
-		const { getName, getFile } = (0, _kubb_plugin_oas_hooks.useSchemaManager)();
-		const imports = (0, _kubb_plugin_oas_utils.getImports)(schema.tree);
-		const schemaFromTree = schema.tree.find((item) => item.keyword === _kubb_plugin_oas.schemaKeywords.schema);
-		let typedName = getName(schema.name, { type: "type" });
-		if (["asConst", "asPascalConst"].includes(enumType) && schemaFromTree && (0, _kubb_plugin_oas.isKeyword)(schemaFromTree, _kubb_plugin_oas.schemaKeywords.enum)) typedName = typedName += "Key";
-		const type = {
-			name: getName(schema.name, { type: "function" }),
-			typedName,
-			file: getFile(schema.name)
-		};
-		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: (0, _kubb_plugin_oas_utils.getBanner)({
-				oas,
-				output,
-				config: driver.config
-			}),
-			footer: (0, _kubb_plugin_oas_utils.getFooter)({
-				oas,
-				output
-			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				schema.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(require_components.Type, {
-				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 require_components.createLiteralTypeNode(value === true ? require_components.createTrue() : require_components.createFalse());
-	if (format === "number" && typeof value === "number") {
-		if (value < 0) return require_components.createLiteralTypeNode(require_components.createPrefixUnaryExpression(require_components.SyntaxKind.MinusToken, require_components.createNumericLiteral(Math.abs(value))));
-		return require_components.createLiteralTypeNode(require_components.createNumericLiteral(value));
-	}
-	return require_components.createLiteralTypeNode(require_components.createStringLiteral(String(value)));
-}
-/**
-* Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.
-*/
-function dateOrStringNode(node) {
-	return node.representation === "date" ? require_components.createTypeReferenceNode(require_components.createIdentifier("Date")) : require_components.keywordTypeNodes.string;
-}
-/**
-* Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
-*/
-function buildMemberNodes(members, print) {
-	return (members ?? []).map(print).filter(Boolean);
-}
-/**
-* Builds a TypeScript tuple type node from an array schema's `items`,
-* applying min/max slice and optional/rest element rules.
-*/
-function buildTupleNode(node, print) {
-	let items = (node.items ?? []).map(print).filter(Boolean);
-	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
-	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 ? require_components.createOptionalTypeNode(item) : item);
-	if (max === void 0 && restNode) items.push(require_components.createRestTypeNode(require_components.createArrayTypeNode(restNode)));
-	return require_components.createTupleTypeNode(items);
-}
-/**
-* Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
-*/
-function buildPropertyType(schema, baseType, optionalType) {
-	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	let type = baseType;
-	if (schema.nullable) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
-	if ((schema.nullish || schema.optional) && addsUndefined) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
-	return type;
-}
-/**
-* Collects JSDoc annotation strings (description, deprecated, min/max, pattern, default, example, type) for a schema node.
-*/
-function buildPropertyJSDocComments(schema) {
-	return [
-		"description" in schema && schema.description ? `@description ${require_components.jsStringEscape(schema.description)}` : void 0,
-		"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) ?? require_components.keywordTypeNodes.unknown;
-		elements.push(require_components.createIndexSignature(propertyCount > 0 ? require_components.keywordTypeNodes.unknown : additionalType));
-	} else if (node.additionalProperties === true) elements.push(require_components.createIndexSignature(require_components.keywordTypeNodes.unknown));
-	if (node.patternProperties) {
-		const first = Object.values(node.patternProperties)[0];
-		if (first) {
-			let patternType = print(first) ?? require_components.keywordTypeNodes.unknown;
-			if (first.nullable) patternType = require_components.createUnionDeclaration({ nodes: [patternType, require_components.keywordTypeNodes.null] });
-			elements.push(require_components.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 = (0, _kubb_core.definePrinter)((options) => {
-	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
-	return {
-		name: "typescript",
-		options,
-		nodes: {
-			any: () => require_components.keywordTypeNodes.any,
-			unknown: () => require_components.keywordTypeNodes.unknown,
-			void: () => require_components.keywordTypeNodes.void,
-			never: () => require_components.keywordTypeNodes.never,
-			boolean: () => require_components.keywordTypeNodes.boolean,
-			null: () => require_components.keywordTypeNodes.null,
-			blob: () => require_components.createTypeReferenceNode("Blob", []),
-			string: () => require_components.keywordTypeNodes.string,
-			uuid: () => require_components.keywordTypeNodes.string,
-			email: () => require_components.keywordTypeNodes.string,
-			url: (node) => {
-				if (node.path) return require_components.createUrlTemplateType(node.path);
-				return require_components.keywordTypeNodes.string;
-			},
-			datetime: () => require_components.keywordTypeNodes.string,
-			number: () => require_components.keywordTypeNodes.number,
-			integer: () => require_components.keywordTypeNodes.number,
-			bigint: () => require_components.keywordTypeNodes.bigint,
-			date: dateOrStringNode,
-			time: dateOrStringNode,
-			ref(node) {
-				if (!node.name) return;
-				return require_components.createTypeReferenceNode(node.name, void 0);
-			},
-			enum(node) {
-				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
-				if (this.options.enumType === "inlineLiteral" || !node.name) {
-					const literalNodes = values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean);
-					return require_components.createUnionDeclaration({
-						withParentheses: true,
-						nodes: literalNodes
-					}) ?? void 0;
-				}
-				const resolvedName = require_components.pascalCase(node.name);
-				const typeName = ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) ? `${resolvedName}Key` : resolvedName;
-				return require_components.createTypeReferenceNode(typeName, void 0);
-			},
-			union(node) {
-				const members = node.members ?? [];
-				const hasStringLiteral = members.some((m) => m.type === "enum" && (m.enumType === "string" || m.primitive === "string"));
-				const hasPlainString = members.some((m) => (0, _kubb_ast.isPlainStringType)(m));
-				if (hasStringLiteral && hasPlainString) {
-					const memberNodes = members.map((m) => {
-						if ((0, _kubb_ast.isPlainStringType)(m)) return require_components.createIntersectionDeclaration({
-							nodes: [require_components.keywordTypeNodes.string, require_components.createTypeLiteralNode([])],
-							withParentheses: true
-						});
-						return this.print(m);
-					}).filter(Boolean);
-					return require_components.createUnionDeclaration({
-						withParentheses: true,
-						nodes: memberNodes
-					}) ?? void 0;
-				}
-				return require_components.createUnionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(members, this.print)
-				}) ?? void 0;
-			},
-			intersection(node) {
-				return require_components.createIntersectionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(node.members, this.print)
-				}) ?? void 0;
-			},
-			array(node) {
-				const itemNodes = (node.items ?? []).map((item) => this.print(item)).filter(Boolean);
-				return require_components.createArrayDeclaration({
-					nodes: itemNodes,
-					arrayType: this.options.arrayType
-				}) ?? void 0;
-			},
-			tuple(node) {
-				return buildTupleNode(node, this.print);
-			},
-			object(node) {
-				const { print, options } = this;
-				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = node.properties.map((prop) => {
-					const baseType = print(prop.schema) ?? require_components.keywordTypeNodes.unknown;
-					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
-					const propertyNode = require_components.createPropertySignature({
-						questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-						name: prop.name,
-						type,
-						readOnly: prop.schema.readOnly
-					});
-					return require_components.appendJSDocToNode({
-						node: propertyNode,
-						comments: buildPropertyJSDocComments(prop.schema)
-					});
-				});
-				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
-				if (!allElements.length) return require_components.keywordTypeNodes.object;
-				return require_components.createTypeLiteralNode(allElements);
-			}
-		},
-		print(node) {
-			let type = this.print(node);
-			if (!type) return;
-			if (node.nullable) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
-			if ((node.nullish || node.optional) && addsUndefined) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
-			const { typeName, syntaxType = "type", description, keysToOmit } = this.options;
-			if (!typeName) return type;
-			const useTypeGeneration = syntaxType === "type" || type.kind === require_components.syntaxKind.union || !!keysToOmit?.length;
-			return require_components.createTypeDeclaration({
-				name: typeName,
-				isExportable: true,
-				type: keysToOmit?.length ? require_components.createOmitDeclaration({
-					keys: keysToOmit,
-					type,
-					nonNullable: true
-				}) : type,
-				syntax: useTypeGeneration ? "type" : "interface",
-				comments: [
-					node?.title ? require_components.jsStringEscape(node.title) : void 0,
-					description ? `@description ${require_components.jsStringEscape(description)}` : void 0,
-					node?.deprecated ? "@deprecated" : void 0,
-					node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
-					node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
-					node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
-					node?.default ? `@default ${node.default}` : void 0,
-					node?.example ? `@example ${node.example}` : void 0
-				]
-			});
-		}
-	};
-});
-//#endregion
-//#region src/components/v2/Enum.tsx
-/**
-* Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
-*
-* The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
-* valid TypeScript identifier. `pascalCase` normalizes it unconditionally; for inline enum
-* properties the adapter already emits a PascalCase+suffix name so `pascalCase` is a no-op.
-*/
-function getEnumNames(node, enumType) {
-	const resolved = require_components.pascalCase(node.name);
-	return {
-		enumName: enumType === "asPascalConst" ? resolved : require_components.camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved
-	};
-}
-/**
-* Renders the enum declaration(s) for a single named `EnumSchemaNode`.
-*
-* Depending on `enumType` this may emit:
-* - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
-* - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
-* - A union literal type alias (`literal`)
-*
-* The emitted `File.Source` nodes carry the resolved names so that the barrel
-* index picks up the correct export identifiers.
-*/
-function Enum({ node, enumType, enumKeyCasing }) {
-	const { enumName, typeName } = getEnumNames(node, enumType);
-	const [nameNode, typeNode] = require_components.createEnumDeclaration({
-		name: enumName,
-		typeName,
-		enums: node.namedEnumValues?.map((v) => [require_components.trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [require_components.trimQuotes(v.toString()), v]) ?? [],
-		type: enumType,
-		enumKeyCasing
-	});
-	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-		name: enumName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: false,
-		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(nameNode)
-	}), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-		name: typeName,
-		isIndexable: true,
-		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
-		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
-		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(typeNode)
-	})] });
-}
-//#endregion
-//#region src/components/v2/Type.tsx
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description }) {
-	const resolvedDescription = description || node?.description;
-	const enumSchemaNodes = (0, _kubb_ast.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(Enum, {
-		node,
-		enumType,
-		enumKeyCasing
-	})), shouldExportType && /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Source, {
-		name: typedName,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(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 = (0, _kubb_core.defineResolver)(() => {
-	return {
-		default(name, type) {
-			return require_components.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 (0, _kubb_ast.createSchema)({
-		type: "object",
-		properties: params.map((param) => (0, _kubb_ast.createProperty)({
-			name: param.name,
-			schema: (0, _kubb_ast.createSchema)({
-				type: "ref",
-				name: resolveName({
-					name: `${operationId} ${require_components.pascalCase(param.in)} ${param.name}`,
-					type: "function"
-				}),
-				optional: !param.required
-			})
-		}))
-	});
-}
-/**
-* Builds an `ObjectSchemaNode` representing the `<OperationId>RequestConfig` type:
-* - `data`         → request body ref (optional) or `never`
-* - `pathParams`   → inline object of path param refs, or `never`
-* - `queryParams`  → inline object of query param refs (optional), or `never`
-* - `headerParams` → inline object of header param refs (optional), or `never`
-* - `url`          → Express-style template literal (plugin-ts extension, handled by printer)
-*/
-function buildDataSchemaNode({ node, resolveName }) {
-	const pathParams = node.parameters.filter((p) => p.in === "path");
-	const queryParams = node.parameters.filter((p) => p.in === "query");
-	const headerParams = node.parameters.filter((p) => p.in === "header");
-	return (0, _kubb_ast.createSchema)({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			(0, _kubb_ast.createProperty)({
-				name: "data",
-				schema: node.requestBody ? (0, _kubb_ast.createSchema)({
-					type: "ref",
-					name: resolveName({
-						name: `${node.operationId} Data`,
-						type: "function"
-					}),
-					optional: true
-				}) : (0, _kubb_ast.createSchema)({
-					type: "never",
-					optional: true
-				})
-			}),
-			(0, _kubb_ast.createProperty)({
-				name: "pathParams",
-				schema: pathParams.length > 0 ? buildParamsSchema({
-					params: pathParams,
-					operationId: node.operationId,
-					resolveName
-				}) : (0, _kubb_ast.createSchema)({
-					type: "never",
-					optional: true
-				})
-			}),
-			(0, _kubb_ast.createProperty)({
-				name: "queryParams",
-				schema: queryParams.length > 0 ? (0, _kubb_ast.createSchema)({
-					...buildParamsSchema({
-						params: queryParams,
-						operationId: node.operationId,
-						resolveName
-					}),
-					optional: true
-				}) : (0, _kubb_ast.createSchema)({
-					type: "never",
-					optional: true
-				})
-			}),
-			(0, _kubb_ast.createProperty)({
-				name: "headerParams",
-				schema: headerParams.length > 0 ? (0, _kubb_ast.createSchema)({
-					...buildParamsSchema({
-						params: headerParams,
-						operationId: node.operationId,
-						resolveName
-					}),
-					optional: true
-				}) : (0, _kubb_ast.createSchema)({
-					type: "never",
-					optional: true
-				})
-			}),
-			(0, _kubb_ast.createProperty)({
-				name: "url",
-				schema: (0, _kubb_ast.createSchema)({
-					type: "url",
-					path: node.path
-				})
-			})
-		]
-	});
-}
-/**
-* Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
-* Numeric status codes produce unquoted numeric keys (e.g. `200:`).
-* 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 (0, _kubb_ast.createSchema)({
-		type: "object",
-		properties: node.responses.map((res) => (0, _kubb_ast.createProperty)({
-			name: String(res.statusCode),
-			schema: (0, _kubb_ast.createSchema)({
-				type: "ref",
-				name: resolveName({
-					name: `${node.operationId} Status ${res.statusCode}`,
-					type: "function"
-				})
-			})
-		}))
-	});
-}
-/**
-* Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
-* Returns `null` when the operation has no responses with schemas.
-*/
-function buildResponseUnionSchemaNode({ node, resolveName }) {
-	const responsesWithSchema = node.responses.filter((res) => res.schema);
-	if (responsesWithSchema.length === 0) return null;
-	return (0, _kubb_ast.createSchema)({
-		type: "union",
-		members: responsesWithSchema.map((res) => (0, _kubb_ast.createSchema)({
-			type: "ref",
-			name: resolveName({
-				name: `${node.operationId} Status ${res.statusCode}`,
-				type: "function"
-			})
-		}))
-	});
-}
-//#endregion
-//#region src/generators/v2/typeGenerator.tsx
-const typeGenerator = (0, _kubb_core.defineGenerator)({
-	name: "typescript",
-	type: "react",
-	Operation({ node, adapter, options }) {
-		const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
-		const { mode, getFile, resolveName, resolveBanner, resolveFooter } = (0, _kubb_core_hooks.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 = (0, _kubb_ast.applyParamsCasing)(node.parameters, paramsCasing);
-		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
-			if (!schemaNode) return null;
-			const imports = adapter.getImports(schemaNode, (schemaName) => ({
-				name: resolveName({
-					name: schemaName,
-					type: "type"
-				}),
-				path: getFile({
-					name: schemaName,
-					extname: ".ts",
-					mode
-				}).path
-			}));
-			return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
-				root: file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.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 } = (0, _kubb_core_hooks.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__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
-			baseName: type.file.baseName,
-			path: type.file.path,
-			meta: type.file.meta,
-			banner: resolveBanner(),
-			footer: resolveFooter(),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.File.Import, {
-				root: type.file.path,
-				path: imp.path,
-				name: imp.name,
-				isTypeOnly: true
-			}, [
-				node.name,
-				imp.path,
-				imp.isTypeOnly
-			].join("-"))), /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.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 = (0, _kubb_core.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: [_kubb_plugin_oas.pluginOasName],
-		resolvePath(baseName, pathMode, options) {
-			const root = node_path.default.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? (0, _kubb_core.getMode)(node_path.default.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 node_path.default.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 `${require_components.camelCase(ctx.group)}Controller`;
-				};
-				return node_path.default.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return node_path.default.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 = node_path.default.resolve(config.root, config.output.path);
-			const mode = (0, _kubb_core.getMode)(node_path.default.resolve(root, output.path));
-			if (adapter) {
-				await openInStudio({ ast: true });
-				await (0, _kubb_ast.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 (0, _kubb_core.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 (0, _kubb_core.renderOperation)(operationNode, {
-									options,
-									adapter,
-									config,
-									fabric,
-									Component: generator.Operation,
-									plugin,
-									driver,
-									mode
-								});
-							}
-						});
-						await Promise.all(writeTasks);
-					}
-				}, { depth: "shallow" });
-				const barrelFiles = await (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
-					type: output.barrelType ?? "named",
-					root,
-					output,
-					meta: { pluginName: this.plugin.name }
-				});
-				await this.upsertFile(...barrelFiles);
-				return;
-			}
-			const oas = await this.getOas();
-			const schemaFiles = await new _kubb_plugin_oas.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 _kubb_plugin_oas.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 (0, _kubb_core.getBarrelFiles)(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
-			});
-			await this.upsertFile(...barrelFiles);
-		}
-	};
-});
-//#endregion
-Object.defineProperty(exports, "pluginTs", {
-	enumerable: true,
-	get: function() {
-		return pluginTs;
-	}
-});
-Object.defineProperty(exports, "pluginTsName", {
-	enumerable: true,
-	get: function() {
-		return pluginTsName;
-	}
-});
-Object.defineProperty(exports, "resolverTs", {
-	enumerable: true,
-	get: function() {
-		return resolverTs;
-	}
-});
-Object.defineProperty(exports, "typeGenerator", {
-	enumerable: true,
-	get: function() {
-		return typeGenerator;
-	}
-});
-Object.defineProperty(exports, "typeGenerator$1", {
-	enumerable: true,
-	get: function() {
-		return typeGenerator$1;
-	}
-});
-
-//# sourceMappingURL=plugin-CJ29AwE2.cjs.map