ts-class-to-openapi 1.4.0 → 1.4.2

package/dist/index.cjs

@@ -28,6 +28,53 @@ path = __toESM(path);
 //#region src/transformer.fixtures.ts
 const constants = {
 	TS_CONFIG_DEFAULT_PATH: path.default.resolve(process.cwd(), "tsconfig.json"),
+	JS_KEYWORDS: new Set([
+		"constructor",
+		"static",
+		"get",
+		"set",
+		"async",
+		"return",
+		"if",
+		"else",
+		"for",
+		"while",
+		"switch",
+		"case",
+		"break",
+		"throw",
+		"new",
+		"delete",
+		"typeof",
+		"void",
+		"try",
+		"catch",
+		"finally",
+		"this",
+		"super",
+		"class",
+		"const",
+		"let",
+		"var",
+		"function",
+		"yield",
+		"await",
+		"import",
+		"export",
+		"default",
+		"extends",
+		"implements",
+		"in",
+		"of",
+		"do",
+		"with",
+		"continue",
+		"instanceof",
+		"true",
+		"false",
+		"null",
+		"undefined"
+	]),
 	jsPrimitives: {
 		String: {
 			type: "String",
@@ -189,6 +236,8 @@ var SchemaTransformer = class SchemaTransformer {
 	maxCacheSize;
 	autoCleanup;
 	classFileIndex = /* @__PURE__ */ new Map();
+	transformCallIndex = /* @__PURE__ */ new Map();
+	nonGenericTransformCalls = /* @__PURE__ */ new Set();
 	constructor(tsConfigPath = constants.TS_CONFIG_DEFAULT_PATH, options = {}) {
 		this.maxCacheSize = options.maxCacheSize ?? 100;
 		this.autoCleanup = options.autoCleanup ?? true;
@@ -200,19 +249,7 @@ var SchemaTransformer = class SchemaTransformer {
 		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);
-				}
-			});
-		});
+		this.buildTransformCallIndex();
 	}
 	getPropertiesByClassDeclaration(classNode, visitedDeclarations = /* @__PURE__ */ new Set(), genericTypeMap = /* @__PURE__ */ new Map()) {
 		if (visitedDeclarations.has(classNode)) return [];
@@ -247,76 +284,89 @@ var SchemaTransformer = class SchemaTransformer {
 	}
 	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;
+		for (const member of members) if (typescript.default.isPropertyDeclaration(member) && (typescript.default.isIdentifier(member.name) || typescript.default.isStringLiteral(member.name))) {
+			var _property$originalPro;
+			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 isPrimitive = this.isPrimitiveType(type) || isEnum;
+			const isClassType = this.isClassType(member);
+			const isArray = this.isArrayProperty(member);
+			const isTypeLiteral = this.isTypeLiteral(member);
+			let genericClassReference = void 0;
+			if (isGeneric && !isPrimitive) {
+				const baseTypeName = type.replace(/\[\]$/, "").trim();
+				if (!this.isPrimitiveType(baseTypeName)) {
+					const matches = this.classFileIndex.get(baseTypeName);
+					if (matches && matches.length > 0 && matches[0]) genericClassReference = matches[0].node;
 				}
-				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;
-					}
+			}
+			const property = {
+				name: propertyName,
+				type,
+				decorators,
+				isOptional,
+				isGeneric,
+				originalProperty: member,
+				isPrimitive,
+				isClassType,
+				isArray,
+				isEnum,
+				isRef: false,
+				isTypeLiteral,
+				genericClassReference
+			};
+			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;
-							}
+			}
+			if (property.isTypeLiteral && property.originalProperty.type !== void 0 && typescript.default.isTypeReferenceNode(property.originalProperty.type) && ((_property$originalPro = property.originalProperty.type.typeArguments) === null || _property$originalPro === void 0 ? void 0 : _property$originalPro.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);
 			}
+			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);
+		return this.checker.typeToString(type);
 	}
 	getTypeNodeToString(typeNode, genericTypeMap = /* @__PURE__ */ new Map()) {
-		if (typescript.default.isTypeReferenceNode(typeNode) && typescript.default.isIdentifier(typeNode.typeName)) {
-			const typeName = typeNode.typeName.text;
+		if (typescript.default.isTypeReferenceNode(typeNode)) {
+			let typeName;
+			if (typescript.default.isIdentifier(typeNode.typeName)) typeName = typeNode.typeName.text;
+			else typeName = typeNode.typeName.right.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) {
+				if (typeName === "Array") return `${this.getTypeNodeToString(typeNode.typeArguments[0], genericTypeMap)}[]`;
 				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;
+			return typeName;
 		}
 		switch (typeNode.kind) {
 			case typescript.default.SyntaxKind.StringKeyword: return constants.jsPrimitives.String.type;
@@ -331,31 +381,31 @@ var SchemaTransformer = class SchemaTransformer {
 				if (meaningfulTypes.length > 0 && meaningfulTypes[0]) return meaningfulTypes[0];
 				if (types.length > 0 && types[0]) return types[0];
 				return "object";
-			default:
-				if (typescript.default.isIndexedAccessTypeNode(typeNode)) {
-					const resolvedType = this.checker.getTypeAtLocation(typeNode);
-					const resolved = this.checker.typeToString(resolvedType);
-					if (this.isPrimitiveType(resolved)) return resolved;
-				}
-				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;
+			default: {
+				const resolvedType = this.checker.getTypeAtLocation(typeNode);
+				const resolved = this.checker.typeToString(resolvedType);
+				if (genericTypeMap && genericTypeMap.has(resolved)) return genericTypeMap.get(resolved);
+				if (this.isPrimitiveType(resolved)) return resolved;
+				if (resolved === "Date") return constants.jsPrimitives.Date.type;
+				if (resolved === "Buffer") return constants.jsPrimitives.Buffer.type;
+				if (resolved === "Uint8Array") return constants.jsPrimitives.Uint8Array.type;
+				return resolved;
+			}
 		}
 	}
 	resolveGenericType(typeNode) {
-		const typeName = typeNode.typeName.text;
+		let typeName;
+		if (typescript.default.isIdentifier(typeNode.typeName)) typeName = typeNode.typeName.text;
+		else typeName = typeNode.typeName.right.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;
+		if (!(type.flags & typescript.default.TypeFlags.Any)) {
+			const resolvedType = this.checker.typeToString(type);
+			if (resolvedType && resolvedType !== typeName) return resolvedType;
+		}
 		return typeName;
 	}
-	getStringFromType(type) {
-		return this.checker.typeToString(type);
-	}
 	extractDecorators(member) {
 		const decorators = [];
 		if (member.modifiers) {
@@ -375,6 +425,7 @@ var SchemaTransformer = class SchemaTransformer {
 	}
 	getDecoratorName(callExpression) {
 		if (typescript.default.isIdentifier(callExpression.expression)) return callExpression.expression.text;
+		if (typescript.default.isPropertyAccessExpression(callExpression.expression)) return callExpression.expression.name.text;
 		return "unknown";
 	}
 	getDecoratorArguments(callExpression) {
@@ -387,7 +438,13 @@ var SchemaTransformer = class SchemaTransformer {
 		});
 	}
 	getSafeDecoratorArgument(arg) {
-		if (arg && typeof arg === "object" && "kind" in arg) return arg.getText();
+		if (arg && typeof arg === "object" && "kind" in arg) {
+			const node = arg;
+			const type = this.checker.getTypeAtLocation(node);
+			if (type.isNumberLiteral()) return type.value;
+			if (type.isStringLiteral()) return type.value;
+			return this.checker.typeToString(type);
+		}
 		return arg;
 	}
 	isPropertyTypeGeneric(property) {
@@ -411,15 +468,18 @@ var SchemaTransformer = class SchemaTransformer {
 	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;
+		if (type.flags & typescript.default.TypeFlags.Object && type.objectFlags & typescript.default.ObjectFlags.Reference) {
+			var _typeArgs$;
+			const typeArgs = this.checker.getTypeArguments(type);
+			if (typeArgs.length > 0 && ((_typeArgs$ = typeArgs[0]) === null || _typeArgs$ === void 0 || (_typeArgs$ = _typeArgs$.getSymbol()) === null || _typeArgs$ === void 0 ? void 0 : _typeArgs$.getName()) === "Array") {
+				const symbol = type.getSymbol();
+				if (symbol && symbol.getName() === "Array") {
+					const elementType = typeArgs[0];
+					return elementType ? this.isUtilityTypeFromType(elementType) : false;
+				}
+				const elementType = typeArgs[0];
+				return elementType ? this.isUtilityTypeFromType(elementType) : 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;
@@ -451,12 +511,18 @@ var SchemaTransformer = class SchemaTransformer {
 	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;
+		if (type.flags & typescript.default.TypeFlags.Object && type.objectFlags & typescript.default.ObjectFlags.Reference) {
+			const typeArgs = this.checker.getTypeArguments(type);
+			if (typeArgs.length === 1) {
+				const elementType = typeArgs[0];
+				if (this.isUtilityTypeFromType(elementType)) return false;
+				if (elementType.flags & typescript.default.TypeFlags.Object && elementType.objectFlags & typescript.default.ObjectFlags.Reference) {
+					if (this.checker.getTypeArguments(elementType).length > 0) return false;
+				}
+				const elementSymbol = elementType.getSymbol();
+				if (elementSymbol && elementSymbol.getName() !== "Array") return false;
+				return true;
+			}
 		}
 		return false;
 	}
@@ -513,40 +579,41 @@ var SchemaTransformer = class SchemaTransformer {
 		}
 		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;
+	findBestMatch(cls, matches) {
+		const runtimeProps = this.extractRuntimePropertyNames(cls);
+		let bestMatch;
+		let bestScore = -1;
+		for (const match of matches) {
+			let score = 0;
+			for (const member of match.node.members) if (typescript.default.isPropertyDeclaration(member) && member.name && (typescript.default.isIdentifier(member.name) || typescript.default.isStringLiteral(member.name))) {
+				if (runtimeProps.has(member.name.text)) score++;
+			}
+			if (score > bestScore) {
+				bestScore = score;
+				bestMatch = match;
+			}
 		}
-		return false;
+		return bestMatch;
 	}
-	findBestMatch(cls, matches) {
-		let instance = {};
+	/**
+	* Safely extracts property names from a class constructor without instantiation.
+	* Parses the class source via Function.prototype.toString() and inspects
+	* the prototype for method names.
+	*/
+	extractRuntimePropertyNames(cls) {
+		const names = /* @__PURE__ */ new Set();
 		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)];
+			const source = Function.prototype.toString.call(cls);
+			const thisAssign = /this\.(\w+)\s*=/g;
+			let m;
+			while ((m = thisAssign.exec(source)) !== null) if (m[1]) names.add(m[1]);
+			const classField = /[;}](\w+)(?=[=;}\s])/g;
+			while ((m = classField.exec(source)) !== null) if (m[1] && !constants.JS_KEYWORDS.has(m[1])) names.add(m[1]);
+		} catch {}
+		try {
+			for (const name of Object.getOwnPropertyNames(cls.prototype)) if (name !== "constructor") names.add(name);
+		} catch {}
+		return names;
 	}
 	getFilteredSourceFiles(sourceOptions) {
 		if (sourceOptions === null || sourceOptions === void 0 ? void 0 : sourceOptions.isExternal) return this.program.getSourceFiles().filter((sf) => {
@@ -561,77 +628,60 @@ var SchemaTransformer = class SchemaTransformer {
 		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);
+		if (typescript.default.isUnionTypeNode(typeNode)) {
+			const nonNullTypes = typeNode.types.filter((t) => t.kind !== typescript.default.SyntaxKind.NullKeyword && t.kind !== typescript.default.SyntaxKind.UndefinedKeyword);
+			if (nonNullTypes.length === 1 && nonNullTypes[0]) typeNode = nonNullTypes[0];
 		}
+		if (typescript.default.isTypeReferenceNode(typeNode)) return !!(this.checker.getTypeAtLocation(typeNode).flags & typescript.default.TypeFlags.EnumLike);
 		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];
+	/**
+	* Resolves a type node to its underlying symbol via the type-checker.
+	* For type references with type arguments (e.g., PayloadEntity<Person>),
+	* it checks the first type argument for a class declaration first.
+	* Returns the ts.Symbol or undefined.
+	*/
+	resolveClassSymbolFromTypeNode(typeNode) {
+		if (typescript.default.isTypeReferenceNode(typeNode) && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+			const firstTypeArg = typeNode.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;
+					if (argSymbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl))) return argSymbol;
 				}
 			}
 		}
-		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];
+		return this.checker.getTypeAtLocation(typeNode).getSymbol() ?? void 0;
+	}
+	/**
+	* Resolves the element type node from an array property declaration.
+	* Handles both `T[]` and `Array<T>` syntax.
+	*/
+	resolveArrayElementTypeNode(propertyDeclaration) {
+		var _propertyDeclaration$;
+		if (!propertyDeclaration.type) return void 0;
+		if (typescript.default.isArrayTypeNode(propertyDeclaration.type)) return propertyDeclaration.type.elementType;
+		if (typescript.default.isTypeReferenceNode(propertyDeclaration.type) && ((_propertyDeclaration$ = propertyDeclaration.type.typeArguments) === null || _propertyDeclaration$ === void 0 ? void 0 : _propertyDeclaration$[0])) return propertyDeclaration.type.typeArguments[0];
+	}
+	isClassType(propertyDeclaration) {
+		if (!propertyDeclaration.type) return false;
+		const typeNode = this.isArrayProperty(propertyDeclaration) ? this.resolveArrayElementTypeNode(propertyDeclaration) : propertyDeclaration.type;
+		if (!typeNode) return false;
+		const symbol = this.resolveClassSymbolFromTypeNode(typeNode);
+		if (symbol && symbol.declarations) return symbol.declarations.some((decl) => typescript.default.isClassDeclaration(decl));
+		return false;
+	}
+	getDeclarationProperty(property) {
+		if (!property.originalProperty.type) return;
+		const typeNode = typescript.default.isArrayTypeNode(property.originalProperty.type) ? property.originalProperty.type.elementType : property.originalProperty.type;
+		const symbol = this.resolveClassSymbolFromTypeNode(typeNode);
+		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);
+		if (typescript.default.isArrayTypeNode(propertyDeclaration.type)) return true;
+		if (typescript.default.isTypeReferenceNode(propertyDeclaration.type) && typescript.default.isIdentifier(propertyDeclaration.type.typeName) && propertyDeclaration.type.typeName.text === "Array") return true;
+		return false;
 	}
 	getSchemaFromProperties({ properties, visitedClass, transformedSchema, classDeclaration }) {
 		let schema = {};
@@ -666,11 +716,34 @@ var SchemaTransformer = class SchemaTransformer {
 			visitedClass,
 			transformedSchema
 		});
-		else schema = {
-			type: "object",
-			properties: {},
-			additionalProperties: true
-		};
+		else if (property.isGeneric) if (property.genericClassReference) schema = this.getSchemaFromClass({
+			isArray: property.isArray,
+			visitedClass,
+			transformedSchema,
+			declaration: property.genericClassReference
+		});
+		else {
+			const inner = {
+				type: "object",
+				properties: {},
+				additionalProperties: true
+			};
+			schema = property.isArray ? {
+				type: "array",
+				items: inner
+			} : inner;
+		}
+		else {
+			const inner = {
+				type: "object",
+				properties: {},
+				additionalProperties: true
+			};
+			schema = property.isArray ? {
+				type: "array",
+				items: inner
+			} : inner;
+		}
 		this.applyDecorators(property, schema);
 		return schema;
 	}
@@ -766,7 +839,12 @@ var SchemaTransformer = class SchemaTransformer {
 			if (enumSchema) return enumSchema;
 		}
 		const propertySchema = { type: "object" };
-		const propertyType = property.type.toLowerCase().replace("[]", "").trim();
+		let baseTypeNode = property.originalProperty.type;
+		if (property.isArray && baseTypeNode) baseTypeNode = this.resolveArrayElementTypeNode(property.originalProperty) ?? baseTypeNode;
+		const resolvedType = this.checker.getTypeAtLocation(baseTypeNode ?? property.originalProperty);
+		let propertyType;
+		if (resolvedType.flags & typescript.default.TypeFlags.TypeParameter) propertyType = property.type.toLowerCase().replace(/\[\]$/, "").trim();
+		else propertyType = this.checker.typeToString(resolvedType).toLowerCase();
 		let isFile = false;
 		switch (propertyType) {
 			case constants.jsPrimitives.String.value:
@@ -803,17 +881,26 @@ var SchemaTransformer = class SchemaTransformer {
 				propertySchema.type = constants.jsPrimitives.Symbol.value;
 				break;
 			case constants.jsPrimitives.Object.value:
+			case "unknown":
+			case "any":
 				propertySchema.type = constants.jsPrimitives.Object.value;
+				propertySchema.additionalProperties = true;
 				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,
+			const resolvedItemType = propertySchema.type;
+			const itemSchema = {
+				type: isFile ? constants.jsPrimitives.UploadFile.value : resolvedItemType,
 				format: isFile ? constants.jsPrimitives.UploadFile.format : propertySchema.format
 			};
+			if (propertySchema.additionalProperties) {
+				itemSchema.additionalProperties = true;
+				delete propertySchema.additionalProperties;
+			}
+			propertySchema.type = `array`;
+			propertySchema.items = itemSchema;
 		}
 		return propertySchema;
 	}
@@ -986,12 +1073,58 @@ var SchemaTransformer = class SchemaTransformer {
 				break;
 		}
 	}
+	/**
+	* Scans all non-declaration source files in the program once and records
+	* every call of the form `transform(Foo<Bar, Baz>)`, keyed by class name.
+	* This means generic resolution in transform() is a pure O(1) Map lookup
+	* with no runtime stack inspection.
+	*/
+	buildTransformCallIndex() {
+		this.program.getSourceFiles().forEach((sf) => {
+			if (sf.isDeclarationFile) return;
+			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);
+				}
+			});
+			const visit = (node) => {
+				if (typescript.default.isCallExpression(node) && node.arguments.length > 0) {
+					const callee = node.expression;
+					if (typescript.default.isIdentifier(callee) && callee.text === "transform" || typescript.default.isPropertyAccessExpression(callee) && callee.name.text === "transform") {
+						const firstArg = node.arguments[0];
+						if (typescript.default.isExpressionWithTypeArguments(firstArg) && firstArg.typeArguments && firstArg.typeArguments.length > 0) {
+							const baseExpr = firstArg.expression;
+							const className = typescript.default.isIdentifier(baseExpr) ? baseExpr.text : typescript.default.isPropertyAccessExpression(baseExpr) ? baseExpr.name.text : void 0;
+							if (className) {
+								var _this$classFileIndex$;
+								const classNode = (_this$classFileIndex$ = this.classFileIndex.get(className)) === null || _this$classFileIndex$ === void 0 || (_this$classFileIndex$ = _this$classFileIndex$[0]) === null || _this$classFileIndex$ === void 0 ? void 0 : _this$classFileIndex$.node;
+								if (classNode === null || classNode === void 0 ? void 0 : classNode.typeParameters) {
+									const typeMap = /* @__PURE__ */ new Map();
+									classNode.typeParameters.forEach((param, i) => {
+										const typeArg = firstArg.typeArguments[i];
+										if (typeArg) typeMap.set(param.name.text, this.getTypeNodeToString(typeArg, /* @__PURE__ */ new Map()));
+									});
+									if (typeMap.size > 0) this.transformCallIndex.set(className, typeMap);
+								}
+							}
+						} else {
+							const className = typescript.default.isIdentifier(firstArg) ? firstArg.text : typescript.default.isPropertyAccessExpression(firstArg) ? firstArg.name.text : void 0;
+							if (className) this.nonGenericTransformCalls.add(className);
+						}
+					}
+				}
+				typescript.default.forEachChild(node, visit);
+			};
+			visit(sf);
+		});
+	}
 	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.`);
@@ -1005,11 +1138,29 @@ var SchemaTransformer = class SchemaTransformer {
 				}
 			};
 		}
-		const properties = this.getPropertiesByClassDeclaration(result.node);
+		const genericTypeMap = /* @__PURE__ */ new Map();
+		if (result.node.typeParameters) {
+			const indexedTypeMap = this.transformCallIndex.get(cls.name);
+			const hasNonGenericCall = this.nonGenericTransformCalls.has(cls.name);
+			const allHaveDefaults = result.node.typeParameters.every((p) => !!p.default);
+			if (indexedTypeMap && !(hasNonGenericCall && allHaveDefaults)) for (const [key, value] of indexedTypeMap) genericTypeMap.set(key, value);
+			else for (const param of result.node.typeParameters) if (param.default) genericTypeMap.set(param.name.text, this.getTypeNodeToString(param.default, /* @__PURE__ */ new Map()));
+		}
+		const hasGenericArgs = genericTypeMap.size > 0;
+		if (!hasGenericArgs && this.classCache.has(cls)) return this.classCache.get(cls);
+		let schema = {
+			type: "object",
+			properties: {}
+		};
+		const properties = this.getPropertiesByClassDeclaration(result.node, void 0, genericTypeMap);
 		schema = this.getSchemaFromProperties({
 			properties,
 			classDeclaration: result.node
 		});
+		if (!hasGenericArgs) this.classCache.set(cls, {
+			name: cls.name,
+			schema
+		});
 		return {
 			name: cls.name,
 			schema