@kubb/plugin-ts 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/plugin-DvK-Uhvv.cjs

@@ -0,0 +1,1013 @@
+const require_components = require("./components-DI0aTIBg.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, pluginManager }) {
+	const properties = {};
+	if (schemas.response) properties["response"] = require_components.createUnionDeclaration({ nodes: schemas.responses.map((res) => {
+		const identifier = pluginManager.resolveName({
+			name: res.name,
+			pluginName: pluginTsName,
+			type: "function"
+		});
+		return require_components.createTypeReferenceNode(require_components.createIdentifier(identifier), void 0);
+	}) });
+	if (schemas.request) {
+		const identifier = pluginManager.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 = pluginManager.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 = pluginManager.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 = pluginManager.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 = pluginManager.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, pluginManager }) {
+	const name = pluginManager.resolveName({
+		name: `${baseName} Request`,
+		pluginName: pluginTsName,
+		type: "type"
+	});
+	const results = [];
+	const dataRequestProperties = [];
+	if (schemas.request) {
+		const identifier = pluginManager.resolveName({
+			name: schemas.request.name,
+			pluginName: pluginTsName,
+			type: "type"
+		});
+		dataRequestProperties.push(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 = pluginManager.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 = pluginManager.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 = pluginManager.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, pluginManager, unknownType }) {
+	const results = [];
+	const name = pluginManager.resolveName({
+		name: `${baseName} ResponseData`,
+		pluginName: pluginTsName,
+		type: "type"
+	});
+	if (schemas.responses && schemas.responses.length > 0) {
+		const responsesProperties = schemas.responses.map((res) => {
+			const identifier = pluginManager.resolveName({
+				name: res.name,
+				pluginName: pluginTsName,
+				type: "type"
+			});
+			return 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: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
+		const mode = (0, _kubb_core_hooks.useMode)();
+		const pluginManager = (0, _kubb_core_hooks.usePluginManager)();
+		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,
+			pluginManager,
+			mode,
+			override: options.override
+		});
+		const operationSchemas = [
+			schemas.pathParams,
+			schemas.queryParams,
+			schemas.headerParams,
+			schemas.statusCodes,
+			schemas.request,
+			schemas.response
+		].flat().filter(Boolean);
+		const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }) => {
+			const transformedSchema = paramsCasing && (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,
+				mapper,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				keysToOmit,
+				syntaxType
+			})] });
+		};
+		const responseName = schemaManager.getName(schemas.response.name, { type: "type" });
+		const combinedSchemaName = operation.method === "get" ? `${name}Query` : `${name}Mutation`;
+		return /* @__PURE__ */ (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: pluginManager.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,
+					pluginManager
+				})
+			}), /* @__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,
+					pluginManager,
+					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,
+					pluginManager
+				})
+			})]
+		});
+	},
+	Schema({ schema, plugin }) {
+		const { options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
+		const mode = (0, _kubb_core_hooks.useMode)();
+		const oas = (0, _kubb_plugin_oas_hooks.useOas)();
+		const pluginManager = (0, _kubb_core_hooks.usePluginManager)();
+		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: pluginManager.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,
+				mapper,
+				enumType,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/printer.ts
+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)));
+}
+function dateOrStringNode(node) {
+	return node.representation === "date" ? require_components.createTypeReferenceNode(require_components.createIdentifier("Date")) : require_components.keywordTypeNodes.string;
+}
+function buildMemberNodes(members, print) {
+	return (members ?? []).map(print).filter(Boolean);
+}
+function buildTupleNode(node, print) {
+	let items = (node.items ?? []).map(print).filter(Boolean);
+	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
+	const { min, max } = node;
+	if (max !== void 0) {
+		items = items.slice(0, max);
+		if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
+	}
+	if (min !== void 0) items = items.map((item, i) => i >= min ? require_components.createOptionalTypeNode(item) : item);
+	if (max === void 0 && restNode) items.push(require_components.createRestTypeNode(require_components.createArrayTypeNode(restNode)));
+	return require_components.createTupleTypeNode(items);
+}
+function buildPropertyType(schema, baseType, optionalType) {
+	const addsUndefined = ["undefined", "questionTokenAndUndefined"].includes(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;
+}
+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
+	];
+}
+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;
+}
+/**
+* Converts a `SchemaNode` AST node into a TypeScript `ts.TypeNode`.
+*
+* Built on `definePrinter` — dispatches on `node.type`, with options closed over
+* per printer instance. Produces the same `ts.TypeNode` output as the keyword-based
+* `parse` in `parser.ts`.
+*/
+const printerTs = (0, _kubb_core.definePrinter)((options) => ({
+	name: "typescript",
+	options,
+	nodes: {
+		any: () => require_components.keywordTypeNodes.any,
+		unknown: () => require_components.keywordTypeNodes.unknown,
+		void: () => require_components.keywordTypeNodes.void,
+		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: () => 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: (node) => dateOrStringNode(node),
+		time: (node) => dateOrStringNode(node),
+		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 === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string")).filter(Boolean);
+				return require_components.createUnionDeclaration({
+					withParentheses: true,
+					nodes: literalNodes
+				}) ?? void 0;
+			}
+			const typeName = ["asConst", "asPascalConst"].includes(this.options.enumType) ? `${node.name}Key` : node.name;
+			return require_components.createTypeReferenceNode(typeName, void 0);
+		},
+		union(node) {
+			const members = node.members ?? [];
+			const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+			const hasPlainString = members.some((m) => (0, _kubb_ast.isPlainStringType)(m));
+			if (hasStringLiteral && hasPlainString) {
+				const nodes = 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
+				}) ?? 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 addsQuestionToken = ["questionToken", "questionTokenAndUndefined"].includes(this.options.optionalType);
+			const { print } = this;
+			const propertyNodes = node.properties.map((prop) => {
+				const baseType = print(prop.schema) ?? require_components.keywordTypeNodes.unknown;
+				const type = buildPropertyType(prop.schema, baseType, this.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);
+		}
+	}
+}));
+//#endregion
+//#region src/components/v2/Type.tsx
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
+	const typeNodes = [];
+	const description = rest.description || node?.description;
+	const enumSchemaNodes = (0, _kubb_ast.collect)(node, { schema(n) {
+		if (n.type === "enum" && n.name) return n;
+	} });
+	let type = printerTs({
+		optionalType,
+		arrayType,
+		enumType
+	}).print(node);
+	if (!type) return;
+	if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
+		const isDirectEnum = node.type === "array" && node.items !== void 0;
+		const isEnumOnly = "enum" in node && node.enum;
+		if (isDirectEnum || isEnumOnly) {
+			const typeNameWithKey = `${enumSchemaNodes[0].name}Key`;
+			type = require_components.createTypeReferenceNode(typeNameWithKey);
+			if (isDirectEnum) if (arrayType === "generic") type = require_components.createTypeReferenceNode(require_components.createIdentifier("Array"), [type]);
+			else type = require_components.createArrayTypeNode(type);
+		}
+	}
+	if (node) {
+		if (node.nullable) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.null] });
+		if (node.nullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
+		if (node.optional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = require_components.createUnionDeclaration({ nodes: [type, require_components.keywordTypeNodes.undefined] });
+	}
+	const useTypeGeneration = syntaxType === "type" || [require_components.syntaxKind.union].includes(type.kind) || !!keysToOmit?.length;
+	typeNodes.push(require_components.createTypeDeclaration({
+		name,
+		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
+		]
+	}));
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((enumSchemaNode) => {
+		const enumName = enumType === "asPascalConst" ? require_components.pascalCase(enumSchemaNode.name) : require_components.camelCase(enumSchemaNode.name);
+		const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchemaNode.name}Key` : enumSchemaNode.name;
+		const [nameNode, typeNode] = require_components.createEnumDeclaration({
+			name: enumName,
+			typeName,
+			enums: enumSchemaNode.namedEnumValues?.map((v) => [require_components.trimQuotes(v.name.toString()), v.value]) ?? enumSchemaNode.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [require_components.trimQuotes(v.toString()), v]) ?? [],
+			type: enumType,
+			enumKeyCasing
+		});
+		return {
+			nameNode,
+			typeNode,
+			name: enumName,
+			typeName
+		};
+	});
+	const shouldExportEnums = enumType !== "inlineLiteral";
+	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ name: enumName, nameNode, typeName, typeNode }) => /* @__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",
+			"asConst",
+			"asPascalConst",
+			"constEnum",
+			"literal",
+			void 0
+		].includes(enumType),
+		isTypeOnly: [
+			"asConst",
+			"asPascalConst",
+			"literal",
+			void 0
+		].includes(enumType),
+		children: (0, _kubb_fabric_core_parsers_typescript.safePrint)(typeNode)
+	})] })), 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)(...typeNodes)
+	})] });
+}
+//#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 } = options;
+		const { plugin, mode, getFile, resolveName } = (0, _kubb_core_hooks.useKubb)();
+		const file = getFile({
+			name: node.operationId,
+			pluginName: plugin.name,
+			extname: ".ts",
+			mode
+		});
+		function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+			const imports = adapter.getImports(schemaNode, (schemaName) => ({
+				name: resolveName({
+					name: schemaName,
+					pluginName: plugin.name,
+					type: "type"
+				}),
+				path: getFile({
+					name: schemaName,
+					pluginName: plugin.name,
+					extname: ".ts",
+					mode
+				}).path
+			}));
+			return /* @__PURE__ */ (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 = node.parameters.map((param) => {
+			const name = resolveName({
+				name: `${node.operationId} ${param.name}`,
+				pluginName: plugin.name,
+				type: "function"
+			});
+			const typedName = resolveName({
+				name: `${node.operationId} ${param.name}`,
+				pluginName: plugin.name,
+				type: "type"
+			});
+			return renderSchemaType({
+				node: param.schema,
+				name,
+				typedName
+			});
+		});
+		const responseTypes = node.responses.filter((res) => res.schema).map((res) => {
+			const schemaNode = res.schema;
+			const responseName = `${node.operationId} ${res.statusCode}`;
+			return renderSchemaType({
+				node: schemaNode,
+				name: resolveName({
+					name: responseName,
+					pluginName: plugin.name,
+					type: "function"
+				}),
+				typedName: resolveName({
+					name: responseName,
+					pluginName: plugin.name,
+					type: "type"
+				}),
+				description: res.description
+			});
+		});
+		const requestType = node.requestBody ? (() => {
+			const requestName = `${node.operationId} MutationRequest`;
+			const resolvedName = resolveName({
+				name: requestName,
+				pluginName: plugin.name,
+				type: "function"
+			});
+			const typedName = resolveName({
+				name: requestName,
+				pluginName: plugin.name,
+				type: "type"
+			});
+			return renderSchemaType({
+				node: node.requestBody,
+				name: resolvedName,
+				typedName,
+				description: node.requestBody.description
+			});
+		})() : null;
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			children: [
+				paramTypes,
+				responseTypes,
+				requestType
+			]
+		});
+	},
+	Schema({ node, adapter, options }) {
+		const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
+		const { plugin, mode, resolveName, getFile } = (0, _kubb_core_hooks.useKubb)();
+		if (!node.name) return;
+		const imports = adapter.getImports(node, (schemaName) => ({
+			name: resolveName({
+				name: schemaName,
+				pluginName: plugin.name,
+				type: "type"
+			}),
+			path: getFile({
+				name: schemaName,
+				pluginName: plugin.name,
+				extname: ".ts",
+				mode
+			}).path
+		}));
+		const isEnumSchema = node.type === "enum";
+		let typedName = resolveName({
+			name: node.name,
+			pluginName: plugin.name,
+			type: "type"
+		});
+		if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName = typedName += "Key";
+		const type = {
+			name: resolveName({
+				name: node.name,
+				pluginName: plugin.name,
+				type: "function"
+			}),
+			typedName,
+			file: getFile({
+				name: node.name,
+				pluginName: plugin.name,
+				extname: ".ts",
+				mode
+			})
+		};
+		return /* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsxs)(_kubb_react_fabric.File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			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.definePlugin)((options) => {
+	const { output = {
+		path: "types",
+		barrelType: "named"
+	}, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+	return {
+		name: pluginTsName,
+		options: {
+			output,
+			transformers,
+			dateType,
+			integerType,
+			optionalType,
+			arrayType,
+			enumType,
+			enumKeyCasing,
+			enumSuffix,
+			unknownType,
+			emptySchemaType,
+			syntaxType,
+			group,
+			override,
+			mapper,
+			paramsCasing,
+			usedEnumNames: {}
+		},
+		pre: [_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 = require_components.pascalCase(name, { isFile: type === "file" });
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this;
+			const root = 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 = (0, _kubb_core.resolveOptions)(schemaNode, {
+									options: plugin.options,
+									exclude,
+									include,
+									override
+								});
+								if (options === null) return;
+								await (0, _kubb_plugin_oas.buildSchema)(schemaNode, {
+									options,
+									adapter,
+									config,
+									fabric,
+									Component: generator.Schema,
+									plugin,
+									pluginManager,
+									mode,
+									version: generator.version
+								});
+							}
+						});
+						await Promise.all(writeTasks);
+					},
+					async operation(operationNode) {
+						const writeTasks = generators.map(async (generator) => {
+							if (generator.type === "react" && generator.version === "2") {
+								const options = (0, _kubb_core.resolveOptions)(operationNode, {
+									options: plugin.options,
+									exclude,
+									include,
+									override
+								});
+								if (options === null) return;
+								await (0, _kubb_plugin_oas.buildOperation)(operationNode, {
+									options,
+									adapter,
+									config,
+									fabric,
+									Component: generator.Operation,
+									plugin,
+									pluginManager,
+									mode,
+									version: generator.version
+								});
+							}
+						});
+						await Promise.all(writeTasks);
+					}
+				}, { depth: "shallow" });
+				return;
+			}
+			const oas = await this.getOas();
+			const schemaFiles = await new _kubb_plugin_oas.SchemaGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				include: void 0,
+				override,
+				mode,
+				output: output.path
+			}).build(...generators);
+			await this.upsertFile(...schemaFiles);
+			const operationFiles = await new _kubb_plugin_oas.OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode,
+				UNSTABLE_NAMING
+			}).build(...generators);
+			await this.upsertFile(...operationFiles);
+			const barrelFiles = await (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, "typeGenerator", {
+	enumerable: true,
+	get: function() {
+		return typeGenerator;
+	}
+});
+Object.defineProperty(exports, "typeGenerator$1", {
+	enumerable: true,
+	get: function() {
+		return typeGenerator$1;
+	}
+});
+
+//# sourceMappingURL=plugin-DvK-Uhvv.cjs.map