ts-class-to-openapi 1.3.2 → 1.3.4

package/dist/index.cjs

@@ -0,0 +1,976 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+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 typescript = require("typescript");
+typescript = __toESM(typescript);
+let path = require("path");
+path = __toESM(path);
+//#region src/transformer.fixtures.ts
+const constants = {
+	TS_CONFIG_DEFAULT_PATH: path.default.resolve(process.cwd(), "tsconfig.json"),
+	jsPrimitives: {
+		String: {
+			type: "String",
+			value: "string"
+		},
+		Any: {
+			type: "Any",
+			value: "string"
+		},
+		Unknown: {
+			type: "Unknown",
+			value: "string"
+		},
+		Number: {
+			type: "Number",
+			value: "number",
+			format: "integer"
+		},
+		Boolean: {
+			type: "Boolean",
+			value: "boolean"
+		},
+		Symbol: {
+			type: "Symbol",
+			value: "string"
+		},
+		BigInt: {
+			type: "BigInt",
+			value: "integer",
+			format: "int64"
+		},
+		null: {
+			type: "null",
+			value: "null"
+		},
+		Object: {
+			type: "Object",
+			value: "object"
+		},
+		Array: {
+			type: "Array",
+			value: "array"
+		},
+		Date: {
+			type: "Date",
+			value: "string",
+			format: "date-time"
+		},
+		Function: {
+			type: "Function",
+			value: "function"
+		},
+		Buffer: {
+			type: "Buffer",
+			value: "string",
+			format: "binary"
+		},
+		Uint8Array: {
+			type: "Uint8Array",
+			value: "string",
+			format: "binary"
+		},
+		UploadFile: {
+			type: "UploadFile",
+			value: "string",
+			format: "binary"
+		},
+		UploadFileDto: {
+			type: "UploadFileDto",
+			value: "string",
+			format: "binary"
+		},
+		File: {
+			type: "File",
+			value: "string",
+			format: "binary"
+		}
+	},
+	validatorDecorators: {
+		Length: {
+			name: "Length",
+			type: "string"
+		},
+		MinLength: {
+			name: "MinLength",
+			type: "string"
+		},
+		MaxLength: {
+			name: "MaxLength",
+			type: "string"
+		},
+		IsInt: {
+			name: "IsInt",
+			type: "integer",
+			format: "int32"
+		},
+		IsNumber: {
+			name: "IsNumber",
+			type: "integer",
+			format: "integer"
+		},
+		IsString: {
+			name: "IsString",
+			type: "string",
+			format: "string"
+		},
+		IsPositive: {
+			name: "IsPositive",
+			type: "integer"
+		},
+		IsDate: {
+			name: "IsDate",
+			type: "string",
+			format: "date-time"
+		},
+		IsEmail: {
+			name: "IsEmail",
+			type: "string",
+			format: "email"
+		},
+		IsNotEmpty: { name: "IsNotEmpty" },
+		IsOptional: { name: "IsOptional" },
+		IsBoolean: {
+			name: "IsBoolean",
+			type: "boolean"
+		},
+		IsArray: {
+			name: "IsArray",
+			type: "array"
+		},
+		Min: { name: "Min" },
+		Max: { name: "Max" },
+		ArrayNotEmpty: { name: "ArrayNotEmpty" },
+		ArrayMaxSize: { name: "ArrayMaxSize" },
+		ArrayMinSize: { name: "ArrayMinSize" },
+		IsEnum: {
+			name: "IsEnum",
+			type: "string"
+		}
+	},
+	tsUtilityTypes: {
+		Partial: {
+			type: "Partial",
+			value: "Partial<"
+		},
+		Required: {
+			type: "Required",
+			value: "Required<"
+		}
+	}
+};
+//#endregion
+//#region src/transformer.ts
+var SchemaTransformer = class SchemaTransformer {
+	static instance = null;
+	program;
+	checker;
+	classCache = /* @__PURE__ */ new WeakMap();
+	maxCacheSize;
+	autoCleanup;
+	classFileIndex = /* @__PURE__ */ new Map();
+	constructor(tsConfigPath = constants.TS_CONFIG_DEFAULT_PATH, options = {}) {
+		this.maxCacheSize = options.maxCacheSize ?? 100;
+		this.autoCleanup = options.autoCleanup ?? true;
+		const { config, error } = typescript.default.readConfigFile(tsConfigPath || "tsconfig.json", typescript.default.sys.readFile);
+		if (error) {
+			console.log((/* @__PURE__ */ new Error(`Error reading tsconfig file: ${error.messageText}`)).message);
+			throw new Error(`Error reading tsconfig file: ${error.messageText}`);
+		}
+		const { options: tsOptions, fileNames } = typescript.default.parseJsonConfigFileContent(config, typescript.default.sys, "./");
+		this.program = typescript.default.createProgram(fileNames, tsOptions);
+		this.checker = this.program.getTypeChecker();
+		this.program.getSourceFiles().forEach((sf) => {
+			sf.statements.forEach((stmt) => {
+				if (typescript.default.isClassDeclaration(stmt) && stmt.name) {
+					const name = stmt.name.text;
+					const entry = this.classFileIndex.get(name) || [];
+					entry.push({
+						sourceFile: sf,
+						node: stmt
+					});
+					this.classFileIndex.set(name, entry);
+				}
+			});
+		});
+	}
+	getPropertiesByClassDeclaration(classNode, visitedDeclarations = /* @__PURE__ */ new Set(), genericTypeMap = /* @__PURE__ */ new Map()) {
+		if (visitedDeclarations.has(classNode)) return [];
+		visitedDeclarations.add(classNode);
+		if (!classNode.heritageClauses) return this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
+		else {
+			const heritageClause = classNode.heritageClauses[0];
+			if (heritageClause && heritageClause.token === typescript.default.SyntaxKind.ExtendsKeyword) {
+				var _symbol$declarations;
+				const type = heritageClause.types[0];
+				let properties = [];
+				let baseProperties = [];
+				if (!type) return [];
+				const symbol = this.checker.getSymbolAtLocation(type.expression);
+				if (!symbol) return [];
+				const declaration = (_symbol$declarations = symbol.declarations) === null || _symbol$declarations === void 0 ? void 0 : _symbol$declarations[0];
+				if (declaration && typescript.default.isClassDeclaration(declaration)) {
+					const newGenericTypeMap = /* @__PURE__ */ new Map();
+					if (declaration.typeParameters && type.typeArguments) declaration.typeParameters.forEach((param, index) => {
+						const arg = type.typeArguments[index];
+						if (arg) {
+							const resolvedArg = this.getTypeNodeToString(arg, genericTypeMap);
+							newGenericTypeMap.set(param.name.text, resolvedArg);
+						}
+					});
+					baseProperties = this.getPropertiesByClassDeclaration(declaration, visitedDeclarations, newGenericTypeMap);
+				}
+				properties = this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
+				return baseProperties.concat(properties);
+			} else return this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
+		}
+	}
+	getPropertiesByClassMembers(members, parentClassNode, genericTypeMap = /* @__PURE__ */ new Map()) {
+		const properties = [];
+		for (const member of members) {
+			var _member$name;
+			if (typescript.default.isPropertyDeclaration(member) && member.name && ((_member$name = member.name) === null || _member$name === void 0 ? void 0 : _member$name.text)) {
+				var _typeArguments;
+				if (member.modifiers) {
+					if (member.modifiers.some((m) => m.kind === typescript.default.SyntaxKind.PrivateKeyword || m.kind === typescript.default.SyntaxKind.ProtectedKeyword)) continue;
+				}
+				const propertyName = member.name.text;
+				const type = this.getPropertyType(member, genericTypeMap);
+				const decorators = this.extractDecorators(member);
+				const isOptional = !!member.questionToken;
+				const isGeneric = this.isPropertyTypeGeneric(member);
+				const isEnum = this.isEnum(member);
+				const property = {
+					name: propertyName,
+					type,
+					decorators,
+					isOptional,
+					isGeneric,
+					originalProperty: member,
+					isPrimitive: this.isPrimitiveType(type) || isEnum,
+					isClassType: this.isClassType(member),
+					isArray: this.isArrayProperty(member),
+					isEnum,
+					isRef: false,
+					isTypeLiteral: this.isTypeLiteral(member)
+				};
+				if (property.isClassType) {
+					const declaration = this.getDeclarationProperty(property);
+					if (parentClassNode) {
+						if (declaration && declaration.name && this.checker.getSymbolAtLocation(declaration.name) === this.checker.getSymbolAtLocation(parentClassNode.name)) property.isRef = true;
+					}
+				}
+				if (property.isTypeLiteral && property.originalProperty.type && ((_typeArguments = property.originalProperty.type.typeArguments) === null || _typeArguments === void 0 ? void 0 : _typeArguments.length) === 1) {
+					const typeArguments = property.originalProperty.type.typeArguments;
+					if (typeArguments && typeArguments[0]) {
+						const firstTypeArg = typeArguments[0];
+						if (typescript.default.isTypeReferenceNode(firstTypeArg)) {
+							const symbol = this.checker.getTypeAtLocation(firstTypeArg).getSymbol();
+							if (symbol && symbol.declarations) {
+								const classDeclaration = symbol.declarations.find((decl) => typescript.default.isClassDeclaration(decl));
+								if (classDeclaration && typescript.default.isClassDeclaration(classDeclaration)) property.typeLiteralClassReference = classDeclaration;
+							}
+						}
+					}
+				}
+				properties.push(property);
+			}
+		}
+		return properties;
+	}
+	getPropertyType(property, genericTypeMap = /* @__PURE__ */ new Map()) {
+		if (property.type) return this.getTypeNodeToString(property.type, genericTypeMap);
+		const type = this.checker.getTypeAtLocation(property);
+		return this.getStringFromType(type);
+	}
+	getTypeNodeToString(typeNode, genericTypeMap = /* @__PURE__ */ new Map()) {
+		if (typescript.default.isTypeReferenceNode(typeNode) && typescript.default.isIdentifier(typeNode.typeName)) {
+			const typeName = typeNode.typeName.text;
+			if (genericTypeMap.has(typeName)) return genericTypeMap.get(typeName);
+			if (typeName.toLowerCase() === "uploadfile") return "UploadFile";
+			if (typeName.toLowerCase() === "uploadfiledto") return "UploadFileDto";
+			if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+				const firstTypeArg = typeNode.typeArguments[0];
+				if (firstTypeArg && typescript.default.isTypeReferenceNode(firstTypeArg) && typescript.default.isIdentifier(firstTypeArg.typeName)) {
+					if (firstTypeArg.typeName.text.toLowerCase() === "uploadfile") return "UploadFile";
+				}
+				return this.resolveGenericType(typeNode);
+			}
+			return typeNode.typeName.text;
+		}
+		switch (typeNode.kind) {
+			case typescript.default.SyntaxKind.StringKeyword: return constants.jsPrimitives.String.type;
+			case typescript.default.SyntaxKind.NumberKeyword: return constants.jsPrimitives.Number.type;
+			case typescript.default.SyntaxKind.BooleanKeyword: return constants.jsPrimitives.Boolean.type;
+			case typescript.default.SyntaxKind.ArrayType:
+				const arrayType = typeNode;
+				return `${this.getTypeNodeToString(arrayType.elementType, genericTypeMap)}[]`;
+			case typescript.default.SyntaxKind.UnionType:
+				const types = typeNode.types.map((t) => this.getTypeNodeToString(t, genericTypeMap));
+				const meaningfulTypes = types.filter((t) => t !== "null" && t !== "undefined");
+				if (meaningfulTypes.length > 0 && meaningfulTypes[0]) return meaningfulTypes[0];
+				if (types.length > 0 && types[0]) return types[0];
+				return "object";
+			default:
+				const typeText = typeNode.getText();
+				if (genericTypeMap && genericTypeMap.has(typeText)) return genericTypeMap.get(typeText);
+				if (typeText.startsWith("Date")) return constants.jsPrimitives.Date.type;
+				if (typeText.includes("Buffer") || typeText.includes("Uint8Array")) return constants.jsPrimitives.Buffer.type;
+				return typeText;
+		}
+	}
+	resolveGenericType(typeNode) {
+		const typeName = typeNode.typeName.text;
+		const typeArguments = typeNode.typeArguments;
+		if (!typeArguments || typeArguments.length === 0) return typeName;
+		const type = this.checker.getTypeAtLocation(typeNode);
+		const resolvedType = this.getStringFromType(type);
+		if (resolvedType && resolvedType !== typeName && !resolvedType.includes("any")) return resolvedType;
+		return typeName;
+	}
+	getStringFromType(type) {
+		return this.checker.typeToString(type);
+	}
+	extractDecorators(member) {
+		const decorators = [];
+		if (member.modifiers) {
+			for (const modifier of member.modifiers) if (typescript.default.isDecorator(modifier) && typescript.default.isCallExpression(modifier.expression)) {
+				const decoratorName = this.getDecoratorName(modifier.expression);
+				const args = this.getDecoratorArguments(modifier.expression);
+				decorators.push({
+					name: decoratorName,
+					arguments: args
+				});
+			} else if (typescript.default.isDecorator(modifier) && typescript.default.isIdentifier(modifier.expression)) decorators.push({
+				name: modifier.expression.text,
+				arguments: []
+			});
+		}
+		return decorators;
+	}
+	getDecoratorName(callExpression) {
+		if (typescript.default.isIdentifier(callExpression.expression)) return callExpression.expression.text;
+		return "unknown";
+	}
+	getDecoratorArguments(callExpression) {
+		return callExpression.arguments.map((arg) => {
+			if (typescript.default.isNumericLiteral(arg)) return Number(arg.text);
+			if (typescript.default.isStringLiteral(arg)) return arg.text;
+			if (arg.kind === typescript.default.SyntaxKind.TrueKeyword) return true;
+			if (arg.kind === typescript.default.SyntaxKind.FalseKeyword) return false;
+			return arg;
+		});
+	}
+	getSafeDecoratorArgument(arg) {
+		if (arg && typeof arg === "object" && "kind" in arg) return arg.getText();
+		return arg;
+	}
+	isPropertyTypeGeneric(property) {
+		if (property.type && this.isGenericTypeFromNode(property.type)) return true;
+		try {
+			const type = this.checker.getTypeAtLocation(property);
+			return this.isGenericTypeFromSymbol(type);
+		} catch (error) {
+			console.warn("Error analyzing property type for generics:", error);
+			return false;
+		}
+	}
+	isGenericTypeFromNode(typeNode) {
+		if (typescript.default.isTypeReferenceNode(typeNode) && typeNode.typeArguments) return typeNode.typeArguments.length > 0;
+		if (typescript.default.isMappedTypeNode(typeNode)) return true;
+		if (typescript.default.isConditionalTypeNode(typeNode)) return true;
+		if (typescript.default.isIndexedAccessTypeNode(typeNode)) return true;
+		if (typescript.default.isTypeOperatorNode(typeNode)) return true;
+		return false;
+	}
+	isGenericTypeFromSymbol(type) {
+		if (this.isSimpleArrayType(type)) return false;
+		if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) return true;
+		if (type.typeArguments && type.typeArguments.length > 0) {
+			const symbol = type.getSymbol();
+			if (symbol && symbol.getName() === "Array") {
+				const elementType = type.typeArguments[0];
+				if (elementType) return this.isUtilityTypeFromType(elementType);
+				return false;
+			}
+			const elementType = type.typeArguments[0];
+			return this.isUtilityTypeFromType(elementType);
+		}
+		if (type.flags & typescript.default.TypeFlags.TypeParameter) return true;
+		if (type.flags & typescript.default.TypeFlags.Conditional) return true;
+		if (type.flags & typescript.default.TypeFlags.Index) return true;
+		if (type.flags & typescript.default.TypeFlags.IndexedAccess) return true;
+		const symbol = type.getSymbol();
+		if (symbol && symbol.declarations) for (const declaration of symbol.declarations) {
+			if (typescript.default.isTypeAliasDeclaration(declaration) && declaration.typeParameters) return true;
+			if (typescript.default.isInterfaceDeclaration(declaration) && declaration.typeParameters) return true;
+			if (typescript.default.isClassDeclaration(declaration) && declaration.typeParameters) return true;
+		}
+		return false;
+	}
+	isUtilityTypeFromType(type) {
+		if (!type.aliasSymbol) return false;
+		const aliasName = type.aliasSymbol.getName();
+		return [
+			"Partial",
+			"Required",
+			"Readonly",
+			"Pick",
+			"Omit",
+			"Record",
+			"Exclude",
+			"Extract",
+			"NonNullable"
+		].includes(aliasName);
+	}
+	isSimpleArrayType(type) {
+		const symbol = type.getSymbol();
+		if (!symbol || symbol.getName() !== "Array") return false;
+		if (type.typeArguments && type.typeArguments.length === 1) {
+			const elementType = type.typeArguments[0];
+			if (!elementType) return false;
+			if (this.isUtilityTypeFromType(elementType)) return false;
+			if (elementType.typeArguments && elementType.typeArguments.length > 0) return false;
+			return true;
+		}
+		return false;
+	}
+	isPrimitiveType(typeName) {
+		const lowerTypeName = typeName.toLowerCase();
+		const primitiveTypes = [
+			constants.jsPrimitives.String.type.toLowerCase(),
+			constants.jsPrimitives.Number.type.toLowerCase(),
+			constants.jsPrimitives.Boolean.type.toLowerCase(),
+			constants.jsPrimitives.Date.type.toLowerCase(),
+			constants.jsPrimitives.Buffer.type.toLowerCase(),
+			constants.jsPrimitives.Uint8Array.type.toLowerCase(),
+			constants.jsPrimitives.File.type.toLowerCase(),
+			constants.jsPrimitives.UploadFile.type.toLowerCase(),
+			constants.jsPrimitives.UploadFileDto.type.toLowerCase(),
+			constants.jsPrimitives.BigInt.type.toLowerCase(),
+			constants.jsPrimitives.Symbol.type.toLowerCase(),
+			constants.jsPrimitives.null.type.toLowerCase(),
+			constants.jsPrimitives.Object.type.toLowerCase(),
+			constants.jsPrimitives.Array.type.toLowerCase(),
+			constants.jsPrimitives.Any.type.toLowerCase(),
+			constants.jsPrimitives.Unknown.type.toLowerCase()
+		];
+		const primitivesArray = primitiveTypes.map((t) => t.concat("[]"));
+		return primitiveTypes.includes(lowerTypeName) || primitivesArray.includes(lowerTypeName);
+	}
+	static getInstance(tsConfigPath, options) {
+		if (!SchemaTransformer.instance) SchemaTransformer.instance = new SchemaTransformer(tsConfigPath, options);
+		return SchemaTransformer.instance;
+	}
+	getSourceFileByClass(cls, sourceOptions) {
+		const className = cls.name;
+		let matches = [];
+		if (sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.isExternal) {
+			const sourceFiles = this.getFilteredSourceFiles(sourceOptions);
+			for (const sourceFile of sourceFiles) {
+				const node = sourceFile.statements.find((stmt) => typescript.default.isClassDeclaration(stmt) && stmt.name && stmt.name.text === className);
+				if (node) matches.push({
+					sourceFile,
+					node
+				});
+			}
+		} else {
+			matches = this.classFileIndex.get(className) || [];
+			if (sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.filePath) matches = matches.filter((m) => m.sourceFile.fileName.includes(sourceOptions.filePath));
+		}
+		if (matches.length === 0) return;
+		if (matches.length === 1) return matches[0];
+		if (matches.length > 1 && !(sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.filePath)) {
+			const bestMatch = this.findBestMatch(cls, matches);
+			if (bestMatch) return bestMatch;
+			const firstMatch = matches[0];
+			if (firstMatch) console.warn(`[ts-class-to-openapi] Warning: Found multiple classes with name '${className}'. Using the first one found in '${firstMatch.sourceFile.fileName}'. To resolve this collision, provide 'sourceOptions.filePath'.`);
+		}
+		return matches[0];
+	}
+	checkTypeMatch(value, typeNode) {
+		const runtimeType = typeof value;
+		if (runtimeType === "string" && typeNode.kind === typescript.default.SyntaxKind.StringKeyword) return true;
+		if (runtimeType === "number" && typeNode.kind === typescript.default.SyntaxKind.NumberKeyword) return true;
+		if (runtimeType === "boolean" && typeNode.kind === typescript.default.SyntaxKind.BooleanKeyword) return true;
+		if (Array.isArray(value) && typescript.default.isArrayTypeNode(typeNode)) {
+			if (value.length === 0) return true;
+			const firstItem = value[0];
+			const elementType = typeNode.elementType;
+			return this.checkTypeMatch(firstItem, elementType);
+		}
+		if (runtimeType === "object" && value !== null && !Array.isArray(value)) {
+			if (typescript.default.isTypeReferenceNode(typeNode) || typeNode.kind === typescript.default.SyntaxKind.ObjectKeyword) return true;
+		}
+		return false;
+	}
+	findBestMatch(cls, matches) {
+		let instance = {};
+		try {
+			instance = new cls();
+		} catch {
+			instance = {};
+		}
+		const instanceProperties = Object.keys(instance);
+		let matchesMap = {};
+		matches.forEach((match, index) => {
+			let fountProperties = 0;
+			match.node.members.map((member) => {
+				if (member.name && instanceProperties.includes(member.name.getText())) fountProperties++;
+			});
+			matchesMap[index] = fountProperties;
+		});
+		const maxMatches = Math.max(...Object.values(matchesMap));
+		return matches[Object.values(matchesMap).findIndex((value) => value === maxMatches)];
+	}
+	getFilteredSourceFiles(sourceOptions) {
+		if (sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.isExternal) return this.program.getSourceFiles().filter((sf) => {
+			return sf.fileName.includes(sourceOptions.packageName) && (!sourceOptions.filePath || sf.fileName === sourceOptions.filePath);
+		});
+		return this.program.getSourceFiles().filter((sf) => {
+			if ((sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.filePath) && !sf.fileName.includes(sourceOptions.filePath)) return false;
+			return true;
+		});
+	}
+	isEnum(propertyDeclaration) {
+		if (!propertyDeclaration.type) return false;
+		let typeNode = propertyDeclaration.type;
+		if (typescript.default.isArrayTypeNode(typeNode)) typeNode = typeNode.elementType;
+		if (typescript.default.isTypeReferenceNode(typeNode)) {
+			const type = this.checker.getTypeAtLocation(typeNode);
+			return !!(type.flags & typescript.default.TypeFlags.Enum) || !!(type.flags & typescript.default.TypeFlags.EnumLiteral);
+		}
+		return false;
+	}
+	isClassType(propertyDeclaration) {
+		if (!propertyDeclaration.type) return false;
+		if (this.isArrayProperty(propertyDeclaration)) {
+			const elementType = propertyDeclaration.type.elementType;
+			if (typescript.default.isTypeReferenceNode(elementType) && elementType.typeArguments && elementType.typeArguments.length > 0) {
+				const firstTypeArg = elementType.typeArguments[0];
+				if (firstTypeArg) {
+					const argSymbol = this.checker.getTypeAtLocation(firstTypeArg).getSymbol();
+					if (argSymbol && argSymbol.declarations) {
+						if (argSymbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl))) return true;
+					}
+				}
+			}
+			const symbol = this.checker.getTypeAtLocation(elementType).getSymbol();
+			if (symbol && symbol.declarations) return symbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl));
+			return false;
+		} else {
+			if (typescript.default.isTypeReferenceNode(propertyDeclaration.type) && propertyDeclaration.type.typeArguments && propertyDeclaration.type.typeArguments.length > 0) {
+				const firstTypeArg = propertyDeclaration.type.typeArguments[0];
+				if (firstTypeArg) {
+					const argSymbol = this.checker.getTypeAtLocation(firstTypeArg).getSymbol();
+					if (argSymbol && argSymbol.declarations) {
+						if (argSymbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl))) return true;
+					}
+				}
+			}
+			const symbol = this.checker.getTypeAtLocation(propertyDeclaration.type).getSymbol();
+			if (symbol && symbol.declarations) return symbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl));
+			return false;
+		}
+	}
+	getDeclarationProperty(property) {
+		if (!property.originalProperty.type) return;
+		if (typescript.default.isArrayTypeNode(property.originalProperty.type)) {
+			const elementType = property.originalProperty.type.elementType;
+			if (typescript.default.isTypeReferenceNode(elementType) && elementType.typeArguments && elementType.typeArguments.length > 0) {
+				const firstTypeArg = elementType.typeArguments[0];
+				if (firstTypeArg) {
+					const argSymbol = this.checker.getTypeAtLocation(firstTypeArg).getSymbol();
+					if (argSymbol && argSymbol.declarations) {
+						const classDecl = argSymbol.declarations.find((decl) => typescript.default.isClassDeclaration(decl));
+						if (classDecl) return classDecl;
+					}
+				}
+			}
+			const symbol = this.checker.getTypeAtLocation(elementType).getSymbol();
+			if (symbol && symbol.declarations) return symbol.declarations.find((decl) => typescript.default.isClassDeclaration(decl)) || symbol.declarations[0];
+			return;
+		}
+		if (typescript.default.isTypeReferenceNode(property.originalProperty.type) && property.originalProperty.type.typeArguments && property.originalProperty.type.typeArguments.length > 0) {
+			const firstTypeArg = property.originalProperty.type.typeArguments[0];
+			if (firstTypeArg) {
+				const argSymbol = this.checker.getTypeAtLocation(firstTypeArg).getSymbol();
+				if (argSymbol && argSymbol.declarations) {
+					const classDecl = argSymbol.declarations.find((decl) => typescript.default.isClassDeclaration(decl));
+					if (classDecl) return classDecl;
+				}
+			}
+		}
+		const symbol = this.checker.getTypeAtLocation(property.originalProperty.type).getSymbol();
+		if (symbol && symbol.declarations) return symbol.declarations.find((decl) => typescript.default.isClassDeclaration(decl)) || symbol.declarations[0];
+	}
+	isArrayProperty(propertyDeclaration) {
+		if (!propertyDeclaration.type) return false;
+		return typescript.default.isArrayTypeNode(propertyDeclaration.type);
+	}
+	getSchemaFromProperties({ properties, visitedClass, transformedSchema, classDeclaration }) {
+		let schema = {};
+		const required = [];
+		for (const property of properties) {
+			schema[property.name] = this.getSchemaFromProperty({
+				property,
+				visitedClass,
+				transformedSchema,
+				classDeclaration
+			});
+			if (!property.isOptional) required.push(property.name);
+		}
+		return {
+			type: "object",
+			properties: schema,
+			required: required.length ? required : void 0
+		};
+	}
+	getSchemaFromProperty({ property, visitedClass, transformedSchema, classDeclaration }) {
+		let schema = {};
+		if (property.isPrimitive) schema = this.getSchemaFromPrimitive(property);
+		else if (property.isClassType) schema = this.buildSchemaFromClass({
+			property,
+			classDeclaration,
+			visitedClass,
+			transformedSchema
+		});
+		else if (property.isTypeLiteral && property.typeLiteralClassReference) schema = this.buildSchemaFromClass({
+			property,
+			classDeclaration: property.typeLiteralClassReference,
+			visitedClass,
+			transformedSchema
+		});
+		else schema = {
+			type: "object",
+			properties: {},
+			additionalProperties: true
+		};
+		this.applyDecorators(property, schema);
+		return schema;
+	}
+	buildSchemaFromClass({ property, classDeclaration, visitedClass, transformedSchema }) {
+		const declaration = this.getDeclarationProperty(property);
+		let schema = {};
+		if (property.isRef && classDeclaration.name) if (property.isArray) {
+			schema.type = "array";
+			schema.items = { $ref: `#/components/schemas/${classDeclaration.name.text}` };
+		} else schema = { $ref: `#/components/schemas/${classDeclaration.name.text}` };
+		else if (property.isTypeLiteral && property.typeLiteralClassReference) schema = this.getSchemaFromClass({
+			isArray: property.isArray,
+			visitedClass,
+			transformedSchema,
+			declaration: property.typeLiteralClassReference
+		});
+		else schema = this.getSchemaFromClass({
+			isArray: property.isArray,
+			visitedClass,
+			transformedSchema,
+			declaration
+		});
+		return schema;
+	}
+	getSchemaFromClass({ transformedSchema = /* @__PURE__ */ new Map(), visitedClass = /* @__PURE__ */ new Set(), declaration, isArray }) {
+		let schema = { type: "object" };
+		if (!declaration || !typescript.default.isClassDeclaration(declaration) || !declaration.name) return { type: "object" };
+		if (visitedClass.has(declaration)) {
+			if (isArray) {
+				schema.type = "array";
+				schema.items = { $ref: `#/components/schemas/${declaration.name.text}` };
+			} else schema = { $ref: `#/components/schemas/${declaration.name.text}` };
+			return schema;
+		}
+		visitedClass.add(declaration);
+		const properties = this.getPropertiesByClassDeclaration(declaration);
+		let transformerProps = this.getSchemaFromProperties({
+			properties,
+			visitedClass,
+			transformedSchema,
+			classDeclaration: declaration
+		});
+		if (isArray) {
+			schema.type = "array";
+			schema.items = {
+				type: transformerProps.type,
+				properties: transformerProps.properties,
+				required: transformerProps.required
+			};
+		} else {
+			schema.type = transformerProps.type;
+			schema.properties = transformerProps.properties;
+			schema.required = transformerProps.required;
+		}
+		transformedSchema.set(declaration.name.text, schema);
+		visitedClass.delete(declaration);
+		return schema;
+	}
+	getSchemaFromEnum(property) {
+		let typeNode = property.originalProperty.type;
+		if (typescript.default.isArrayTypeNode(typeNode)) typeNode = typeNode.elementType;
+		const type = this.checker.getTypeAtLocation(typeNode);
+		if (type.symbol && type.symbol.exports) {
+			const values = [];
+			type.symbol.exports.forEach((member) => {
+				const declaration = member.valueDeclaration;
+				if (declaration && typescript.default.isEnumMember(declaration)) {
+					const value = this.checker.getConstantValue(declaration);
+					if (value !== void 0) values.push(value);
+				}
+			});
+			if (values.length > 0) {
+				const propertySchema = { type: "object" };
+				propertySchema.enum = values;
+				const isString = values.every((v) => typeof v === "string");
+				const isNumber = values.every((v) => typeof v === "number");
+				if (isString) propertySchema.type = "string";
+				else if (isNumber) propertySchema.type = "number";
+				else propertySchema.type = "string";
+				if (property.isArray) {
+					const itemsSchema = { ...propertySchema };
+					propertySchema.type = "array";
+					propertySchema.items = itemsSchema;
+					delete propertySchema.enum;
+					return propertySchema;
+				} else return propertySchema;
+			}
+		}
+	}
+	getSchemaFromPrimitive(property) {
+		if (property.isEnum) {
+			const enumSchema = this.getSchemaFromEnum(property);
+			if (enumSchema) return enumSchema;
+		}
+		const propertySchema = { type: "object" };
+		const propertyType = property.type.toLowerCase().replace("[]", "").trim();
+		let isFile = false;
+		switch (propertyType) {
+			case constants.jsPrimitives.String.value:
+				propertySchema.type = constants.jsPrimitives.String.value;
+				break;
+			case constants.jsPrimitives.Number.value:
+				propertySchema.type = constants.jsPrimitives.Number.value;
+				propertySchema.format = constants.jsPrimitives.Number.format;
+				break;
+			case constants.jsPrimitives.BigInt.type.toLocaleLowerCase():
+				propertySchema.type = constants.jsPrimitives.BigInt.value;
+				propertySchema.format = constants.jsPrimitives.BigInt.format;
+				break;
+			case constants.jsPrimitives.Date.type.toLocaleLowerCase():
+				propertySchema.type = constants.jsPrimitives.Date.value;
+				propertySchema.format = constants.jsPrimitives.Date.format;
+				break;
+			case constants.jsPrimitives.Buffer.type.toLocaleLowerCase():
+			case constants.jsPrimitives.Uint8Array.type.toLocaleLowerCase():
+			case constants.jsPrimitives.File.type.toLocaleLowerCase():
+			case constants.jsPrimitives.UploadFile.type.toLocaleLowerCase():
+			case constants.jsPrimitives.UploadFileDto.type.toLocaleLowerCase():
+				propertySchema.type = constants.jsPrimitives.UploadFile.value;
+				propertySchema.format = constants.jsPrimitives.UploadFile.format;
+				isFile = true;
+				break;
+			case constants.jsPrimitives.Array.value:
+				propertySchema.type = constants.jsPrimitives.Array.value;
+				break;
+			case constants.jsPrimitives.Boolean.value:
+				propertySchema.type = constants.jsPrimitives.Boolean.value;
+				break;
+			case constants.jsPrimitives.Symbol.type.toLocaleLowerCase():
+				propertySchema.type = constants.jsPrimitives.Symbol.value;
+				break;
+			case constants.jsPrimitives.Object.value:
+				propertySchema.type = constants.jsPrimitives.Object.value;
+				break;
+			default: propertySchema.type = constants.jsPrimitives.String.value;
+		}
+		if (property.isArray) {
+			delete propertySchema.format;
+			propertySchema.type = `array`;
+			propertySchema.items = {
+				type: isFile ? constants.jsPrimitives.UploadFile.value : propertyType,
+				format: isFile ? constants.jsPrimitives.UploadFile.format : propertySchema.format
+			};
+		}
+		return propertySchema;
+	}
+	isTypeLiteral(property) {
+		if (!property.type) return false;
+		if (typescript.default.isTypeReferenceNode(property.type)) {
+			const symbol = this.checker.getSymbolAtLocation(property.type.typeName);
+			if (symbol) {
+				const declarations = symbol.getDeclarations();
+				if (declarations && declarations.length > 0) {
+					const typeAliasDecl = declarations.find((decl) => typescript.default.isTypeAliasDeclaration(decl));
+					if (typeAliasDecl && typeAliasDecl.type) return this.isLiteralTypeNode(typeAliasDecl.type);
+				}
+			}
+		}
+		return false;
+	}
+	/**
+	*
+	* @param typeNode
+	* @returns boolean - true si el typeNode representa un tipo literal complejo
+	*/
+	isLiteralTypeNode(typeNode) {
+		return typescript.default.isIntersectionTypeNode(typeNode) || typescript.default.isUnionTypeNode(typeNode) || typescript.default.isMappedTypeNode(typeNode) || typescript.default.isTypeLiteralNode(typeNode) || typescript.default.isConditionalTypeNode(typeNode) || typescript.default.isIndexedAccessTypeNode(typeNode) || typescript.default.isTypeOperatorNode(typeNode) || typescript.default.isTypeReferenceNode(typeNode);
+	}
+	applyEnumDecorator(decorator, schema) {
+		if (decorator.arguments.length === 0) return;
+		const arg = decorator.arguments[0];
+		if (arg && typeof arg === "object" && "kind" in arg) {
+			const type = this.checker.getTypeAtLocation(arg);
+			if (type.symbol && type.symbol.exports) {
+				const values = [];
+				type.symbol.exports.forEach((member) => {
+					const declaration = member.valueDeclaration;
+					if (declaration && typescript.default.isEnumMember(declaration)) {
+						const value = this.checker.getConstantValue(declaration);
+						if (value !== void 0) values.push(value);
+					}
+				});
+				if (values.length > 0) {
+					schema.enum = values;
+					const isString = values.every((v) => typeof v === "string");
+					const isNumber = values.every((v) => typeof v === "number");
+					if (isString) schema.type = "string";
+					else if (isNumber) schema.type = "number";
+					else schema.type = "string";
+				}
+			}
+		}
+	}
+	applyDecorators(property, schema) {
+		for (const decorator of property.decorators) switch (decorator.name) {
+			case constants.validatorDecorators.IsString.name:
+				if (!property.isArray) schema.type = constants.validatorDecorators.IsString.type;
+				else if (schema.items) schema.items.type = constants.validatorDecorators.IsString.type;
+				break;
+			case constants.validatorDecorators.IsInt.name:
+				if (!property.isArray) {
+					schema.type = constants.validatorDecorators.IsInt.type;
+					schema.format = constants.validatorDecorators.IsInt.format;
+				} else if (schema.items) {
+					schema.items.type = constants.validatorDecorators.IsInt.type;
+					schema.items.format = constants.validatorDecorators.IsInt.format;
+				}
+				break;
+			case constants.validatorDecorators.IsNumber.name:
+				if (!property.isArray) schema.type = constants.validatorDecorators.IsNumber.type;
+				else if (schema.items) schema.items.type = constants.validatorDecorators.IsNumber.type;
+				break;
+			case constants.validatorDecorators.IsBoolean.name:
+				if (!property.isArray) schema.type = constants.validatorDecorators.IsBoolean.type;
+				else if (schema.items) schema.items.type = constants.validatorDecorators.IsBoolean.type;
+				break;
+			case constants.validatorDecorators.IsEmail.name:
+				if (!property.isArray) schema.format = constants.validatorDecorators.IsEmail.format;
+				else if (schema.items) schema.items.format = constants.validatorDecorators.IsEmail.format;
+				break;
+			case constants.validatorDecorators.IsDate.name:
+				if (!property.isArray) {
+					schema.type = constants.validatorDecorators.IsDate.type;
+					schema.format = constants.validatorDecorators.IsDate.format;
+				} else if (schema.items) {
+					schema.items.type = constants.validatorDecorators.IsDate.type;
+					schema.items.format = constants.validatorDecorators.IsDate.format;
+				}
+				break;
+			case constants.validatorDecorators.IsNotEmpty.name:
+				property.isOptional = false;
+				break;
+			case constants.validatorDecorators.IsOptional.name:
+				property.isOptional = true;
+				break;
+			case constants.validatorDecorators.MinLength.name:
+				schema.minLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.MaxLength.name:
+				schema.maxLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.Length.name:
+				schema.minLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				if (decorator.arguments[1]) schema.maxLength = this.getSafeDecoratorArgument(decorator.arguments[1]);
+				break;
+			case constants.validatorDecorators.Min.name:
+				schema.minimum = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.Max.name:
+				schema.maximum = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.IsPositive.name:
+				schema.minimum = 0;
+				break;
+			case constants.validatorDecorators.IsArray.name:
+				schema.type = constants.jsPrimitives.Array.value;
+				break;
+			case constants.validatorDecorators.ArrayNotEmpty.name:
+				schema.minItems = 1;
+				property.isOptional = false;
+				break;
+			case constants.validatorDecorators.ArrayMinSize.name:
+				schema.minItems = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.ArrayMaxSize.name:
+				schema.maxItems = this.getSafeDecoratorArgument(decorator.arguments[0]);
+				break;
+			case constants.validatorDecorators.IsEnum.name:
+				if (!property.isArray) this.applyEnumDecorator(decorator, schema);
+				else if (schema.items) this.applyEnumDecorator(decorator, schema.items);
+				break;
+		}
+	}
+	transform(cls, sourceOptions) {
+		if (this.classCache.has(cls)) return this.classCache.get(cls);
+		let schema = {
+			type: "object",
+			properties: {}
+		};
+		const result = this.getSourceFileByClass(cls, sourceOptions);
+		if (!result || !(result === null || result === void 0 ? void 0 : result.sourceFile)) {
+			console.warn(`Class ${cls.name} not found in any source file.`);
+			return {
+				name: cls.name,
+				schema: {
+					type: "object",
+					required: [],
+					properties: {},
+					additionalProperties: true
+				}
+			};
+		}
+		const properties = this.getPropertiesByClassDeclaration(result.node);
+		schema = this.getSchemaFromProperties({
+			properties,
+			classDeclaration: result.node
+		});
+		return {
+			name: cls.name,
+			schema
+		};
+	}
+};
+function transform(cls, options) {
+	return SchemaTransformer.getInstance(void 0, options).transform(cls, options === null || options === void 0 ? void 0 : options.sourceOptions);
+}
+//#endregion
+exports.transform = transform;