@kubb/plugin-ts 4.1.4 → 4.2.1

package/dist/components-Cf7RuPmU.cjs

@@ -0,0 +1,580 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let __kubb_core_transformers = require("@kubb/core/transformers");
+__kubb_core_transformers = __toESM(__kubb_core_transformers);
+let __kubb_plugin_oas = require("@kubb/plugin-oas");
+__kubb_plugin_oas = __toESM(__kubb_plugin_oas);
+let __kubb_fabric_core_parsers_typescript = require("@kubb/fabric-core/parsers/typescript");
+__kubb_fabric_core_parsers_typescript = __toESM(__kubb_fabric_core_parsers_typescript);
+let __kubb_react = require("@kubb/react");
+__kubb_react = __toESM(__kubb_react);
+let __kubb_react_jsx_runtime = require("@kubb/react/jsx-runtime");
+__kubb_react_jsx_runtime = __toESM(__kubb_react_jsx_runtime);
+let remeda = require("remeda");
+remeda = __toESM(remeda);
+let typescript = require("typescript");
+typescript = __toESM(typescript);
+
+//#region src/components/OasType.tsx
+function OasType({ name, typeName, api }) {
+	return /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsxs)(__kubb_react_jsx_runtime.Fragment, { children: [
+		/* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`
+		}),
+		/* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)("br", {}),
+		/* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.File.Source, {
+			name: typeName,
+			isExportable: true,
+			isIndexable: true,
+			isTypeOnly: true,
+			children: /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.Type, {
+				name: typeName,
+				export: true,
+				children: `Infer<typeof ${name}>`
+			})
+		})
+	] });
+}
+
+//#endregion
+//#region src/factory.ts
+const { SyntaxKind, factory } = typescript.default;
+const modifiers = {
+	async: factory.createModifier(typescript.default.SyntaxKind.AsyncKeyword),
+	export: factory.createModifier(typescript.default.SyntaxKind.ExportKeyword),
+	const: factory.createModifier(typescript.default.SyntaxKind.ConstKeyword),
+	static: factory.createModifier(typescript.default.SyntaxKind.StaticKeyword)
+};
+const syntaxKind = { union: SyntaxKind.UnionType };
+function isValidIdentifier(str) {
+	if (!str.length || str.trim() !== str) return false;
+	const node = typescript.default.parseIsolatedEntityName(str, typescript.default.ScriptTarget.Latest);
+	return !!node && node.kind === typescript.default.SyntaxKind.Identifier && typescript.default.identifierToKeywordKind(node.kind) === void 0;
+}
+function propertyName(name) {
+	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
+	return name;
+}
+const questionToken = factory.createToken(typescript.default.SyntaxKind.QuestionToken);
+function createQuestionToken(token) {
+	if (!token) return;
+	if (token === true) return questionToken;
+	return token;
+}
+function createIntersectionDeclaration({ nodes, withParentheses }) {
+	if (!nodes.length) return null;
+	if (nodes.length === 1) return nodes[0] || null;
+	const node = factory.createIntersectionTypeNode(nodes);
+	if (withParentheses) return factory.createParenthesizedType(node);
+	return node;
+}
+function createArrayDeclaration({ nodes }) {
+	if (!nodes.length) return factory.createTupleTypeNode([]);
+	if (nodes.length === 1) return factory.createArrayTypeNode(nodes.at(0));
+	return factory.createExpressionWithTypeArguments(factory.createIdentifier("Array"), [factory.createUnionTypeNode(nodes)]);
+}
+/**
+* Minimum nodes length of 2
+* @example `string | number`
+*/
+function createUnionDeclaration({ nodes, withParentheses }) {
+	if (!nodes.length) return keywordTypeNodes.any;
+	if (nodes.length === 1) return nodes[0];
+	const node = factory.createUnionTypeNode(nodes);
+	if (withParentheses) return factory.createParenthesizedType(node);
+	return node;
+}
+function createPropertySignature({ readOnly, modifiers: modifiers$1 = [], name, questionToken: questionToken$1, type }) {
+	return factory.createPropertySignature([...modifiers$1, readOnly ? factory.createToken(typescript.default.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken$1), type);
+}
+function createParameterSignature(name, { modifiers: modifiers$1, dotDotDotToken, questionToken: questionToken$1, type, initializer }) {
+	return factory.createParameterDeclaration(modifiers$1, dotDotDotToken, name, createQuestionToken(questionToken$1), type, initializer);
+}
+/**
+* @link https://github.com/microsoft/TypeScript/issues/44151
+*/
+function appendJSDocToNode({ node, comments }) {
+	const filteredComments = comments.filter(Boolean);
+	if (!filteredComments.length) return node;
+	const text = filteredComments.reduce((acc = "", comment = "") => {
+		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
+	}, "*");
+	return typescript.default.addSyntheticLeadingComment({ ...node }, typescript.default.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+}
+function createIndexSignature(type, { modifiers: modifiers$1, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword) } = {}) {
+	return factory.createIndexSignature(modifiers$1, [createParameterSignature(indexName, { type: indexType })], type);
+}
+function createTypeAliasDeclaration({ modifiers: modifiers$1, name, typeParameters, type }) {
+	return factory.createTypeAliasDeclaration(modifiers$1, name, typeParameters, type);
+}
+function createInterfaceDeclaration({ modifiers: modifiers$1, name, typeParameters, members }) {
+	return factory.createInterfaceDeclaration(modifiers$1, name, typeParameters, void 0, members);
+}
+function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
+	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
+		node: createInterfaceDeclaration({
+			members: type.members,
+			modifiers: isExportable ? [modifiers.export] : [],
+			name,
+			typeParameters: void 0
+		}),
+		comments
+	});
+	return appendJSDocToNode({
+		node: createTypeAliasDeclaration({
+			type,
+			modifiers: isExportable ? [modifiers.export] : [],
+			name,
+			typeParameters: void 0
+		}),
+		comments
+	});
+}
+function createEnumDeclaration({ type = "enum", name, typeName, enums }) {
+	if (type === "literal") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
+		if ((0, remeda.isNumber)(value)) return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
+		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
+		if (value) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
+	}).filter(Boolean)))];
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter(Boolean), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		if (Number.parseInt(value.toString(), 10) === value && (0, remeda.isNumber)(Number.parseInt(value.toString(), 10))) initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if ((0, remeda.isNumber)(Number.parseInt(key.toString(), 10))) return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer);
+		if (key) return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer);
+	}).filter(Boolean))];
+	const identifierName = type === "asPascalConst" ? typeName : name;
+	return [factory.createVariableStatement([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		if ((0, remeda.isNumber)(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		else initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if (key) return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer);
+	}).filter(Boolean), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.default.NodeFlags.Const)), factory.createTypeAliasDeclaration(type === "asPascalConst" ? [] : [factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+}
+function createOmitDeclaration({ keys, type, nonNullable }) {
+	const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier("NonNullable"), [type]) : type;
+	if (Array.isArray(keys)) return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createUnionTypeNode(keys.map((key) => {
+		return factory.createLiteralTypeNode(factory.createStringLiteral(key));
+	}))]);
+	return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))]);
+}
+const keywordTypeNodes = {
+	any: factory.createKeywordTypeNode(typescript.default.SyntaxKind.AnyKeyword),
+	unknown: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UnknownKeyword),
+	void: factory.createKeywordTypeNode(typescript.default.SyntaxKind.VoidKeyword),
+	number: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
+	integer: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
+	object: factory.createKeywordTypeNode(typescript.default.SyntaxKind.ObjectKeyword),
+	string: factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword),
+	boolean: factory.createKeywordTypeNode(typescript.default.SyntaxKind.BooleanKeyword),
+	undefined: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UndefinedKeyword),
+	null: factory.createLiteralTypeNode(factory.createToken(typescript.default.SyntaxKind.NullKeyword))
+};
+const createTypeLiteralNode = factory.createTypeLiteralNode;
+const createTypeReferenceNode = factory.createTypeReferenceNode;
+const createNumericLiteral = factory.createNumericLiteral;
+const createStringLiteral = factory.createStringLiteral;
+const createArrayTypeNode = factory.createArrayTypeNode;
+const createLiteralTypeNode = factory.createLiteralTypeNode;
+const createNull = factory.createNull;
+const createIdentifier = factory.createIdentifier;
+const createOptionalTypeNode = factory.createOptionalTypeNode;
+const createTupleTypeNode = factory.createTupleTypeNode;
+const createRestTypeNode = factory.createRestTypeNode;
+const createTrue = factory.createTrue;
+const createFalse = factory.createFalse;
+
+//#endregion
+//#region src/parser.ts
+const typeKeywordMapper = {
+	any: () => keywordTypeNodes.any,
+	unknown: () => keywordTypeNodes.unknown,
+	void: () => keywordTypeNodes.void,
+	number: () => keywordTypeNodes.number,
+	integer: () => keywordTypeNodes.number,
+	object: (nodes) => {
+		if (!nodes || !nodes.length) return keywordTypeNodes.object;
+		return createTypeLiteralNode(nodes);
+	},
+	string: () => keywordTypeNodes.string,
+	boolean: () => keywordTypeNodes.boolean,
+	undefined: () => keywordTypeNodes.undefined,
+	nullable: void 0,
+	null: () => keywordTypeNodes.null,
+	nullish: void 0,
+	array: (nodes) => {
+		if (!nodes) return;
+		return createArrayDeclaration({ nodes });
+	},
+	tuple: (nodes, rest, min, max) => {
+		if (!nodes) return;
+		if (max) {
+			nodes = nodes.slice(0, max);
+			if (nodes.length < max && rest) nodes = [...nodes, ...Array(max - nodes.length).fill(rest)];
+		}
+		if (min) nodes = nodes.map((node, index) => index >= min ? createOptionalTypeNode(node) : node);
+		if (typeof max === "undefined" && rest) nodes.push(createRestTypeNode(createArrayTypeNode(rest)));
+		return createTupleTypeNode(nodes);
+	},
+	enum: (name) => {
+		if (!name) return;
+		return createTypeReferenceNode(name, void 0);
+	},
+	union: (nodes) => {
+		if (!nodes) return;
+		return createUnionDeclaration({
+			withParentheses: true,
+			nodes
+		});
+	},
+	const: (name, format) => {
+		if (name === null || name === void 0 || name === "") return;
+		if (format === "boolean") {
+			if (name === true) return createLiteralTypeNode(createTrue());
+			return createLiteralTypeNode(createFalse());
+		}
+		if (format === "number" && typeof name === "number") return createLiteralTypeNode(createNumericLiteral(name));
+		return createLiteralTypeNode(createStringLiteral(name.toString()));
+	},
+	datetime: () => keywordTypeNodes.string,
+	date: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
+	time: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
+	uuid: () => keywordTypeNodes.string,
+	url: () => keywordTypeNodes.string,
+	default: void 0,
+	and: (nodes) => {
+		if (!nodes) return;
+		return createIntersectionDeclaration({
+			withParentheses: true,
+			nodes
+		});
+	},
+	describe: void 0,
+	min: void 0,
+	max: void 0,
+	optional: void 0,
+	matches: () => keywordTypeNodes.string,
+	email: () => keywordTypeNodes.string,
+	firstName: void 0,
+	lastName: void 0,
+	password: void 0,
+	phone: void 0,
+	readOnly: void 0,
+	writeOnly: void 0,
+	ref: (propertyName$1) => {
+		if (!propertyName$1) return;
+		return createTypeReferenceNode(propertyName$1, void 0);
+	},
+	blob: () => createTypeReferenceNode("Blob", []),
+	deprecated: void 0,
+	example: void 0,
+	schema: void 0,
+	catchall: void 0,
+	name: void 0,
+	interface: void 0
+};
+/**
+* Recursively parses a schema tree node into a corresponding TypeScript AST node.
+*
+* Maps OpenAPI schema keywords to TypeScript AST nodes using the `typeKeywordMapper`, handling complex types such as unions, intersections, arrays, tuples (with optional/rest elements and length constraints), enums, constants, references, and objects with property modifiers and documentation annotations.
+*
+* @param current - The schema node to parse.
+* @param siblings - Sibling schema nodes, used for context in certain mappings.
+* @param name - The name of the schema or property being parsed.
+* @param options - Parsing options controlling output style, property handling, and custom mappers.
+* @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.
+*/
+function parse({ current, siblings, name }, options) {
+	const value = typeKeywordMapper[current.keyword];
+	if (!value) return;
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.union)) return typeKeywordMapper.union(current.args.map((schema) => parse({
+		parent: current,
+		name,
+		current: schema,
+		siblings
+	}, options)).filter(Boolean));
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.and)) return typeKeywordMapper.and(current.args.map((schema) => parse({
+		parent: current,
+		name,
+		current: schema,
+		siblings
+	}, options)).filter(Boolean));
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.array)) return typeKeywordMapper.array(current.args.items.map((schema) => parse({
+		parent: current,
+		name,
+		current: schema,
+		siblings
+	}, options)).filter(Boolean));
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.enum)) return typeKeywordMapper.enum(options.enumType === "asConst" ? `${current.args.typeName}Key` : current.args.typeName);
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.ref)) return typeKeywordMapper.ref(current.args.name);
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.blob)) return value();
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.tuple)) return typeKeywordMapper.tuple(current.args.items.map((schema) => parse({
+		parent: current,
+		name,
+		current: schema,
+		siblings
+	}, options)).filter(Boolean), current.args.rest && (parse({
+		parent: current,
+		name,
+		current: current.args.rest,
+		siblings
+	}, options) ?? void 0), current.args.min, current.args.max);
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.const)) return typeKeywordMapper.const(current.args.name, current.args.format);
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.object)) {
+		const properties = Object.entries(current.args?.properties || {}).filter((item) => {
+			const schemas = item[1];
+			return schemas && typeof schemas.map === "function";
+		}).map(([name$1, schemas]) => {
+			const mappedName = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.name)?.args || name$1;
+			if (options.mapper?.[mappedName]) return options.mapper?.[mappedName];
+			const isNullish = schemas.some((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.nullish);
+			const isNullable = schemas.some((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.nullable);
+			const isOptional = schemas.some((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.optional);
+			const isReadonly = schemas.some((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.readOnly);
+			const describeSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.describe);
+			const deprecatedSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.deprecated);
+			const defaultSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.default);
+			const exampleSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.example);
+			const schemaSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.schema);
+			const minSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.min);
+			const maxSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.max);
+			const matchesSchema = schemas.find((schema) => schema.keyword === __kubb_plugin_oas.schemaKeywords.matches);
+			let type = schemas.map((schema) => parse({
+				parent: current,
+				name: name$1,
+				current: schema,
+				siblings: schemas
+			}, options)).filter(Boolean)[0];
+			if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+			if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+			if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+			const propertyNode = createPropertySignature({
+				questionToken: isOptional || isNullish ? ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType) : false,
+				name: mappedName,
+				type,
+				readOnly: isReadonly
+			});
+			return appendJSDocToNode({
+				node: propertyNode,
+				comments: [
+					describeSchema ? `@description ${__kubb_core_transformers.default.jsStringEscape(describeSchema.args)}` : void 0,
+					deprecatedSchema ? "@deprecated" : void 0,
+					minSchema ? `@minLength ${minSchema.args}` : void 0,
+					maxSchema ? `@maxLength ${maxSchema.args}` : void 0,
+					matchesSchema ? `@pattern ${matchesSchema.args}` : void 0,
+					defaultSchema ? `@default ${defaultSchema.args}` : void 0,
+					exampleSchema ? `@example ${exampleSchema.args}` : void 0,
+					schemaSchema?.args?.type || schemaSchema?.args?.format ? [`@type ${schemaSchema?.args?.type || "unknown"}${!isOptional ? "" : " | undefined"}`, schemaSchema?.args?.format].filter(Boolean).join(", ") : void 0
+				].filter(Boolean)
+			});
+		});
+		let additionalProperties;
+		if (current.args?.additionalProperties?.length) {
+			additionalProperties = current.args.additionalProperties.map((schema) => parse({
+				parent: current,
+				name,
+				current: schema,
+				siblings
+			}, options)).filter(Boolean).at(0);
+			if (current.args?.additionalProperties.some((schema) => (0, __kubb_plugin_oas.isKeyword)(schema, __kubb_plugin_oas.schemaKeywords.nullable))) additionalProperties = createUnionDeclaration({ nodes: [additionalProperties, keywordTypeNodes.null] });
+			additionalProperties = createIndexSignature(additionalProperties);
+		}
+		return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean));
+	}
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.datetime)) return typeKeywordMapper.datetime();
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.date)) return typeKeywordMapper.date(current.args.type);
+	if ((0, __kubb_plugin_oas.isKeyword)(current, __kubb_plugin_oas.schemaKeywords.time)) return typeKeywordMapper.time(current.args.type);
+	if (current.keyword in typeKeywordMapper) return value();
+}
+
+//#endregion
+//#region src/components/Type.tsx
+function Type({ name, typedName, tree, keysToOmit, schema, optionalType, syntaxType, enumType, mapper, description }) {
+	const typeNodes = [];
+	if (!tree.length) return "";
+	const schemaFromTree = tree.find((item) => item.keyword === __kubb_plugin_oas.schemaKeywords.schema);
+	const enumSchemas = __kubb_plugin_oas.SchemaGenerator.deepSearch(tree, __kubb_plugin_oas.schemaKeywords.enum);
+	let type = tree.map((current, _index, siblings) => parse({
+		parent: void 0,
+		current,
+		siblings
+	}, {
+		name,
+		typedName,
+		description,
+		keysToOmit,
+		optionalType,
+		enumType,
+		mapper,
+		syntaxType
+	})).filter(Boolean).at(0) || typeKeywordMapper.undefined();
+	if (enumType === "asConst" && enumSchemas.length > 0) {
+		const isDirectEnum = schema.type === "array" && schema.items !== void 0;
+		const isEnumOnly = "enum" in schema && schema.enum;
+		if (isDirectEnum || isEnumOnly) {
+			const typeNameWithKey = `${enumSchemas[0].args.typeName}Key`;
+			type = createTypeReferenceNode(typeNameWithKey);
+			if (schema.type === "array") type = createArrayTypeNode(type);
+		}
+	}
+	if (schemaFromTree && (0, __kubb_plugin_oas.isKeyword)(schemaFromTree, __kubb_plugin_oas.schemaKeywords.schema)) {
+		const isNullish = tree.some((item) => item.keyword === __kubb_plugin_oas.schemaKeywords.nullish);
+		const isNullable = tree.some((item) => item.keyword === __kubb_plugin_oas.schemaKeywords.nullable);
+		const isOptional = tree.some((item) => item.keyword === __kubb_plugin_oas.schemaKeywords.optional);
+		if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+		if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+		if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	}
+	const useTypeGeneration = syntaxType === "type" || [syntaxKind.union].includes(type.kind) || !!keysToOmit?.length;
+	typeNodes.push(createTypeDeclaration({
+		name,
+		isExportable: true,
+		type: keysToOmit?.length ? createOmitDeclaration({
+			keys: keysToOmit,
+			type,
+			nonNullable: true
+		}) : type,
+		syntax: useTypeGeneration ? "type" : "interface",
+		comments: [
+			description ? `@description ${__kubb_core_transformers.default.jsStringEscape(description)}` : void 0,
+			schema.deprecated ? "@deprecated" : void 0,
+			schema.minLength ? `@minLength ${schema.minLength}` : void 0,
+			schema.maxLength ? `@maxLength ${schema.maxLength}` : void 0,
+			schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+			schema.default ? `@default ${schema.default}` : void 0,
+			schema.example ? `@example ${schema.example}` : void 0
+		]
+	}));
+	const enums = [...new Set(enumSchemas)].map((enumSchema) => {
+		const name$1 = enumType === "asPascalConst" ? __kubb_core_transformers.default.pascalCase(enumSchema.args.name) : __kubb_core_transformers.default.camelCase(enumSchema.args.name);
+		const typeName = enumType === "asConst" ? `${enumSchema.args.typeName}Key` : enumSchema.args.typeName;
+		const [nameNode, typeNode] = createEnumDeclaration({
+			name: name$1,
+			typeName,
+			enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [__kubb_core_transformers.default.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
+			type: enumType
+		});
+		return {
+			nameNode,
+			typeNode,
+			name: name$1,
+			typeName
+		};
+	});
+	return /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsxs)(__kubb_react_jsx_runtime.Fragment, { children: [enums.map(({ name: name$1, nameNode, typeName, typeNode }) => /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsxs)(__kubb_react_jsx_runtime.Fragment, { children: [nameNode && /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.File.Source, {
+		name: name$1,
+		isExportable: true,
+		isIndexable: true,
+		children: (0, __kubb_fabric_core_parsers_typescript.print)([nameNode])
+	}), /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.File.Source, {
+		name: typeName,
+		isIndexable: true,
+		isExportable: [
+			"enum",
+			"asConst",
+			"constEnum",
+			"literal",
+			void 0
+		].includes(enumType),
+		isTypeOnly: [
+			"asConst",
+			"literal",
+			void 0
+		].includes(enumType),
+		children: (0, __kubb_fabric_core_parsers_typescript.print)([typeNode])
+	})] })), enums.every((item) => item.typeName !== name) && /* @__PURE__ */ (0, __kubb_react_jsx_runtime.jsx)(__kubb_react.File.Source, {
+		name: typedName,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: (0, __kubb_fabric_core_parsers_typescript.print)(typeNodes)
+	})] });
+}
+
+//#endregion
+Object.defineProperty(exports, 'OasType', {
+  enumerable: true,
+  get: function () {
+    return OasType;
+  }
+});
+Object.defineProperty(exports, 'Type', {
+  enumerable: true,
+  get: function () {
+    return Type;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'createIdentifier', {
+  enumerable: true,
+  get: function () {
+    return createIdentifier;
+  }
+});
+Object.defineProperty(exports, 'createPropertySignature', {
+  enumerable: true,
+  get: function () {
+    return createPropertySignature;
+  }
+});
+Object.defineProperty(exports, 'createTypeAliasDeclaration', {
+  enumerable: true,
+  get: function () {
+    return createTypeAliasDeclaration;
+  }
+});
+Object.defineProperty(exports, 'createTypeLiteralNode', {
+  enumerable: true,
+  get: function () {
+    return createTypeLiteralNode;
+  }
+});
+Object.defineProperty(exports, 'createTypeReferenceNode', {
+  enumerable: true,
+  get: function () {
+    return createTypeReferenceNode;
+  }
+});
+Object.defineProperty(exports, 'createUnionDeclaration', {
+  enumerable: true,
+  get: function () {
+    return createUnionDeclaration;
+  }
+});
+Object.defineProperty(exports, 'modifiers', {
+  enumerable: true,
+  get: function () {
+    return modifiers;
+  }
+});
+//# sourceMappingURL=components-Cf7RuPmU.cjs.map