@tsoa-next/cli 8.0.1-dev.43.63e57e36 → 8.0.1-dev.44.a051324b

package/dist/metadataGeneration/typeResolver.js

@@ -51,6 +51,8 @@ const propertyTransformer_1 = require("./transformer/propertyTransformer");
 const referenceTransformer_1 = require("./transformer/referenceTransformer");
 const localReferenceTypeCache = {};
 const inProgressTypes = {};
+const escapedDoubleQuote = String.raw `\"`;
+const backslash = '\\';
 const hasInitializer = (declaration) => 'initializer' in declaration && declaration.initializer !== undefined;
 const objectHasOwn = Object.hasOwn;
 const getSyntheticOrigin = (symbol) => {
@@ -71,6 +73,36 @@ const isRefTypeTokenCharacter = (char) => {
     const code = char.codePointAt(0) ?? -1;
     return isAsciiLetter(char) || (code >= 48 && code <= 57) || char === '_';
 };
+const readRefTypeToken = (value, startIndex) => {
+    let nextIndex = startIndex;
+    while (nextIndex < value.length && isRefTypeTokenCharacter(value[nextIndex])) {
+        nextIndex += 1;
+    }
+    if (value[nextIndex] === '?') {
+        nextIndex += 1;
+    }
+    return {
+        token: value.slice(startIndex, nextIndex),
+        nextIndex,
+    };
+};
+const readRefTypeLiteralTypeSegment = (value, colonIndex) => {
+    if (value[colonIndex] !== ':') {
+        return undefined;
+    }
+    const typeStart = colonIndex + 1;
+    let typeEnd = typeStart;
+    while (typeEnd < value.length && isAsciiLetter(value[typeEnd])) {
+        typeEnd += 1;
+    }
+    if (typeEnd === typeStart) {
+        return undefined;
+    }
+    return {
+        replacement: `-${value.slice(typeStart, typeEnd)}`,
+        nextIndex: typeEnd,
+    };
+};
 const replaceTypeLiteralPropertySeparators = (value) => {
     let formatted = '';
     let index = 0;
@@ -80,29 +112,15 @@ const replaceTypeLiteralPropertySeparators = (value) => {
             index += 1;
             continue;
         }
-        const tokenStart = index;
-        while (index < value.length && isRefTypeTokenCharacter(value[index])) {
-            index += 1;
-        }
-        if (value[index] === '?') {
-            index += 1;
-        }
-        const token = value.slice(tokenStart, index);
-        if (value[index] === ':') {
-            const typeStart = index + 1;
-            let typeEnd = typeStart;
-            while (typeEnd < value.length && isAsciiLetter(value[typeEnd])) {
-                typeEnd += 1;
-            }
-            if (typeEnd > typeStart) {
-                formatted += token;
-                formatted += '-';
-                formatted += value.slice(typeStart, typeEnd);
-                index = typeEnd;
-                continue;
-            }
-        }
+        const { nextIndex, token } = readRefTypeToken(value, index);
         formatted += token;
+        const literalTypeSegment = readRefTypeLiteralTypeSegment(value, nextIndex);
+        if (literalTypeSegment) {
+            formatted += literalTypeSegment.replacement;
+            index = literalTypeSegment.nextIndex;
+            continue;
+        }
+        index = nextIndex;
     }
     return formatted;
 };
@@ -157,362 +175,300 @@ class TypeResolver {
         });
     }
     resolve() {
-        const partentJsDocTagNames = this.parentNode ? (0, jsDocUtils_1.getJSDocTagNames)(this.parentNode) : undefined;
-        const primitiveType = new primitiveTransformer_1.PrimitiveTransformer().transform(this.current.defaultNumberType, this.typeNode, partentJsDocTagNames);
+        const parentJsDocTagNames = this.parentNode ? (0, jsDocUtils_1.getJSDocTagNames)(this.parentNode) : undefined;
+        const primitiveType = new primitiveTransformer_1.PrimitiveTransformer().transform(this.current.defaultNumberType, this.typeNode, parentJsDocTagNames);
         if (primitiveType) {
             return primitiveType;
         }
-        if (ts.isArrayTypeNode(this.typeNode)) {
-            const arrayMetaType = {
-                dataType: 'array',
-                elementType: new TypeResolver(this.typeNode.elementType, this.current, this.parentNode, this.context).resolve(),
-            };
-            return arrayMetaType;
+        const nonReferenceType = this.resolveNonReferenceTypeNode();
+        if (nonReferenceType) {
+            return nonReferenceType;
         }
-        if (ts.isRestTypeNode(this.typeNode)) {
-            return new TypeResolver(this.typeNode.type, this.current, this.parentNode, this.context).resolve();
+        (0, flowUtils_1.throwUnless)(ts.isTypeReferenceNode(this.typeNode), new exceptions_1.GenerateMetadataError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode));
+        return this.resolveTypeReferenceNode(this.typeNode, this.current, this.context, this.parentNode);
+    }
+    resolveNonReferenceTypeNode() {
+        return (this.resolveArrayTypeNode() ??
+            this.resolveRestTypeNode() ??
+            this.resolveUnionTypeNode() ??
+            this.resolveIntersectionTypeNode() ??
+            this.resolveTupleTypeNode() ??
+            this.resolveAnyOrUnknownTypeNode() ??
+            this.resolveLiteralTypeNode() ??
+            this.resolveTypeLiteralNode() ??
+            this.resolveObjectKeywordTypeNode() ??
+            this.resolveMappedTypeNode() ??
+            this.resolveConditionalTypeNode() ??
+            this.resolveTypeOperatorTypeNode() ??
+            this.resolveIndexedAccessTypeNodeWrapper() ??
+            this.resolveTemplateLiteralTypeNode() ??
+            this.resolveParenthesizedTypeNode());
+    }
+    resolveArrayTypeNode() {
+        if (!ts.isArrayTypeNode(this.typeNode)) {
+            return undefined;
         }
-        if (ts.isUnionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map(type => {
-                return new TypeResolver(type, this.current, this.parentNode, this.context).resolve();
-            });
-            const unionMetaType = {
-                dataType: 'union',
-                types,
-            };
-            return unionMetaType;
+        return {
+            dataType: 'array',
+            elementType: new TypeResolver(this.typeNode.elementType, this.current, this.parentNode, this.context).resolve(),
+        };
+    }
+    resolveRestTypeNode() {
+        if (!ts.isRestTypeNode(this.typeNode)) {
+            return undefined;
         }
-        if (ts.isIntersectionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types
-                .filter(type => !this.isIoTsBrandMarker(type, this.current.typeChecker))
-                .map(type => {
-                return new TypeResolver(type, this.current, this.parentNode, this.context).resolve();
-            });
-            const intersectionMetaType = {
-                dataType: 'intersection',
-                types,
-            };
-            return intersectionMetaType;
-        }
-        if (ts.isTupleTypeNode(this.typeNode)) {
-            const elementTypes = [];
-            let restType;
-            for (const element of this.typeNode.elements) {
-                if (ts.isRestTypeNode(element)) {
-                    const resolvedRest = new TypeResolver(element.type, this.current, element, this.context).resolve();
-                    if (resolvedRest.dataType === 'array') {
-                        restType = resolvedRest.elementType;
-                    }
-                    else {
-                        restType = resolvedRest;
-                    }
-                }
-                else {
-                    const typeNode = ts.isNamedTupleMember(element) ? element.type : element;
-                    const type = new TypeResolver(typeNode, this.current, element, this.context).resolve();
-                    elementTypes.push(type);
-                }
+        return new TypeResolver(this.typeNode.type, this.current, this.parentNode, this.context).resolve();
+    }
+    resolveUnionTypeNode() {
+        if (!ts.isUnionTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return {
+            dataType: 'union',
+            types: this.typeNode.types.map(type => new TypeResolver(type, this.current, this.parentNode, this.context).resolve()),
+        };
+    }
+    resolveIntersectionTypeNode() {
+        if (!ts.isIntersectionTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return {
+            dataType: 'intersection',
+            types: this.typeNode.types.filter(type => !this.isIoTsBrandMarker(type, this.current.typeChecker)).map(type => new TypeResolver(type, this.current, this.parentNode, this.context).resolve()),
+        };
+    }
+    resolveTupleTypeNode() {
+        if (!ts.isTupleTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        const elementTypes = [];
+        let restType;
+        for (const element of this.typeNode.elements) {
+            if (ts.isRestTypeNode(element)) {
+                restType = this.resolveTupleRestTypeNode(element);
+                continue;
             }
+            const typeNode = ts.isNamedTupleMember(element) ? element.type : element;
+            elementTypes.push(new TypeResolver(typeNode, this.current, element, this.context).resolve());
+        }
+        return {
+            dataType: 'tuple',
+            types: elementTypes,
+            ...(restType ? { restType } : {}),
+        };
+    }
+    resolveTupleRestTypeNode(element) {
+        const resolvedRest = new TypeResolver(element.type, this.current, element, this.context).resolve();
+        return resolvedRest.dataType === 'array' ? resolvedRest.elementType : resolvedRest;
+    }
+    resolveAnyOrUnknownTypeNode() {
+        if (this.typeNode.kind !== ts.SyntaxKind.AnyKeyword && this.typeNode.kind !== ts.SyntaxKind.UnknownKeyword) {
+            return undefined;
+        }
+        return { dataType: 'any' };
+    }
+    resolveLiteralTypeNode() {
+        if (!ts.isLiteralTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return {
+            dataType: 'enum',
+            enums: [this.getLiteralValue(this.typeNode)],
+        };
+    }
+    resolveTypeLiteralNode() {
+        if (!ts.isTypeLiteralNode(this.typeNode)) {
+            return undefined;
+        }
+        const properties = this.typeNode.members.filter(ts.isPropertySignature).reduce((result, propertySignature) => [this.resolveTypeLiteralProperty(propertySignature), ...result], []);
+        return {
+            additionalProperties: this.resolveTypeLiteralAdditionalProperties(this.typeNode),
+            dataType: 'nestedObjectLiteral',
+            properties,
+        };
+    }
+    resolveTypeLiteralProperty(propertySignature) {
+        return {
+            example: this.getNodeExample(propertySignature),
+            default: TypeResolver.getDefault(propertySignature),
+            description: this.getNodeDescription(propertySignature),
+            format: this.getNodeFormat(propertySignature),
+            name: this.getPropertyName(propertySignature),
+            required: !propertySignature.questionToken,
+            type: new TypeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve(),
+            validators: (0, validatorUtils_1.getPropertyValidators)(propertySignature) || {},
+            deprecated: (0, jsDocUtils_1.isExistJSDocTag)(propertySignature, tag => tag.tagName.text === 'deprecated'),
+            title: this.getNodeTitle(propertySignature),
+            extensions: this.getNodeExtension(propertySignature),
+        };
+    }
+    resolveTypeLiteralAdditionalProperties(typeLiteralNode) {
+        const indexMember = typeLiteralNode.members.find(member => ts.isIndexSignatureDeclaration(member));
+        if (!indexMember) {
+            return undefined;
+        }
+        const indexType = new TypeResolver(indexMember.parameters[0].type, this.current, this.parentNode, this.context).resolve();
+        (0, flowUtils_1.throwUnless)(indexType.dataType === 'string', new exceptions_1.GenerateMetadataError(`Only string indexers are supported.`, this.typeNode));
+        return new TypeResolver(indexMember.type, this.current, this.parentNode, this.context).resolve();
+    }
+    resolveObjectKeywordTypeNode() {
+        if (this.typeNode.kind !== ts.SyntaxKind.ObjectKeyword) {
+            return undefined;
+        }
+        return { dataType: 'object' };
+    }
+    resolveMappedTypeNode() {
+        if (!ts.isMappedTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return this.resolveMappedType(this.getReferencer(), this.typeNode);
+    }
+    getOriginalMappedDeclaration(prop) {
+        const declaration = prop.declarations?.[0];
+        if (declaration) {
+            return declaration;
+        }
+        const syntheticOrigin = getSyntheticOrigin(prop);
+        if (syntheticOrigin?.name === prop.name) {
+            // Otherwise loses jsDoc like in intellisense.
+            return syntheticOrigin.declarations?.[0];
+        }
+        return undefined;
+    }
+    isIgnoredMappedProperty(prop) {
+        const declaration = this.getOriginalMappedDeclaration(prop);
+        if (!declaration) {
+            return false;
+        }
+        const ignoredTargets = !ts.isPropertyDeclaration(declaration) && !ts.isPropertySignature(declaration) && !ts.isParameter(declaration);
+        return (0, jsDocUtils_1.getJSDocTagNames)(declaration).includes('ignore') || ignoredTargets;
+    }
+    resolveMappedType(type, mappedTypeNode) {
+        if (this.hasFlag(type, ts.TypeFlags.Union)) {
             return {
-                dataType: 'tuple',
-                types: elementTypes,
-                ...(restType ? { restType } : {}),
+                dataType: 'union',
+                types: type.types.map(unionType => this.resolveMappedType(unionType, mappedTypeNode)),
             };
         }
-        if (this.typeNode.kind === ts.SyntaxKind.AnyKeyword || this.typeNode.kind === ts.SyntaxKind.UnknownKeyword) {
-            const literallyAny = {
-                dataType: 'any',
-            };
-            return literallyAny;
+        if (this.hasFlag(type, ts.TypeFlags.Undefined)) {
+            return { dataType: 'undefined' };
         }
-        if (ts.isLiteralTypeNode(this.typeNode)) {
-            const enumType = {
+        if (this.hasFlag(type, ts.TypeFlags.Null)) {
+            return {
                 dataType: 'enum',
-                enums: [this.getLiteralValue(this.typeNode)],
-            };
-            return enumType;
-        }
-        if (ts.isTypeLiteralNode(this.typeNode)) {
-            const properties = this.typeNode.members.filter(ts.isPropertySignature).reduce((res, propertySignature) => {
-                const type = new TypeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve();
-                const def = TypeResolver.getDefault(propertySignature);
-                const property = {
-                    example: this.getNodeExample(propertySignature),
-                    default: def,
-                    description: this.getNodeDescription(propertySignature),
-                    format: this.getNodeFormat(propertySignature),
-                    name: this.getPropertyName(propertySignature),
-                    required: !propertySignature.questionToken,
-                    type,
-                    validators: (0, validatorUtils_1.getPropertyValidators)(propertySignature) || {},
-                    deprecated: (0, jsDocUtils_1.isExistJSDocTag)(propertySignature, tag => tag.tagName.text === 'deprecated'),
-                    title: this.getNodeTitle(propertySignature),
-                    extensions: this.getNodeExtension(propertySignature),
-                };
-                return [property, ...res];
-            }, []);
-            const indexMember = this.typeNode.members.find(member => ts.isIndexSignatureDeclaration(member));
-            let additionalType;
-            if (indexMember) {
-                /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-                const indexSignatureDeclaration = indexMember;
-                const indexType = new TypeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-                (0, flowUtils_1.throwUnless)(indexType.dataType === 'string', new exceptions_1.GenerateMetadataError(`Only string indexers are supported.`, this.typeNode));
-                additionalType = new TypeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
-            }
-            const objLiteral = {
-                additionalProperties: indexMember && additionalType,
-                dataType: 'nestedObjectLiteral',
-                properties,
+                enums: [null],
             };
-            return objLiteral;
         }
-        if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword) {
-            return { dataType: 'object' };
+        if (this.hasFlag(type, ts.TypeFlags.Object)) {
+            return this.resolveMappedObjectType(type, mappedTypeNode);
         }
-        if (ts.isMappedTypeNode(this.typeNode)) {
-            const mappedTypeNode = this.typeNode;
-            const getOneOrigDeclaration = (prop) => {
-                const declaration = prop.declarations?.[0];
-                if (declaration) {
-                    return declaration;
-                }
-                const syntheticOrigin = getSyntheticOrigin(prop);
-                if (syntheticOrigin && syntheticOrigin.name === prop.name) {
-                    //Otherwise losts jsDoc like in intellisense
-                    return syntheticOrigin.declarations?.[0];
-                }
-                return undefined;
-            };
-            const isIgnored = (prop) => {
-                const declaration = getOneOrigDeclaration(prop);
-                return (declaration !== undefined &&
-                    ((0, jsDocUtils_1.getJSDocTagNames)(declaration).some(tag => tag === 'ignore') || (!ts.isPropertyDeclaration(declaration) && !ts.isPropertySignature(declaration) && !ts.isParameter(declaration))));
-            };
-            const calcMappedType = (type) => {
-                if (this.hasFlag(type, ts.TypeFlags.Union)) {
-                    //Intersections are not interesting somehow...
-                    const types = type.types;
-                    const resolvedTypes = types.map(calcMappedType);
-                    return {
-                        dataType: 'union',
-                        types: resolvedTypes,
-                    };
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.Undefined)) {
-                    return {
-                        dataType: 'undefined',
-                    };
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.Null)) {
-                    return {
-                        dataType: 'enum',
-                        enums: [null],
-                    };
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.Object)) {
-                    const typeProperties = type.getProperties();
-                    const properties = typeProperties
-                        // Ignore methods, getter, setter and @ignored props
-                        .filter(property => isIgnored(property) === false)
-                        // Transform to property
-                        .map(property => {
-                        const propertyType = this.current.typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
-                        const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
-                        const parent = getOneOrigDeclaration(property); //If there are more declarations, we need to get one of them, from where we want to recognize jsDoc
-                        const type = new TypeResolver(typeNode, this.current, parent, this.context, propertyType).resolve();
-                        const required = !this.hasFlag(property, ts.SymbolFlags.Optional);
-                        const comments = property.getDocumentationComment(this.current.typeChecker);
-                        const description = comments.length ? ts.displayPartsToString(comments) : undefined;
-                        const initializer = parent && hasInitializer(parent) ? parent.initializer : undefined;
-                        let def;
-                        if (initializer) {
-                            def = (0, initializer_value_1.getInitializerValue)(initializer, this.current.typeChecker);
-                        }
-                        else if (parent) {
-                            def = TypeResolver.getDefault(parent);
-                        }
-                        // Push property
-                        return {
-                            name: property.getName(),
-                            required,
-                            deprecated: parent
-                                ? (0, jsDocUtils_1.isExistJSDocTag)(parent, tag => tag.tagName.text === 'deprecated') || (0, decoratorUtils_1.isDecorator)(parent, (_identifier, canonicalName) => canonicalName === 'Deprecated', this.current.typeChecker)
-                                : false,
-                            type,
-                            default: def,
-                            // validators are disjunct via types, so it is now OK.
-                            // if a type not changes while mapping, we need validators
-                            // if a type changes, then the validators will be not relevant
-                            validators: (parent ? (0, validatorUtils_1.getPropertyValidators)(parent) : {}) || {},
-                            description,
-                            format: parent ? this.getNodeFormat(parent) : undefined,
-                            example: parent ? this.getNodeExample(parent) : undefined,
-                            extensions: parent ? this.getNodeExtension(parent) : undefined,
-                        };
-                    });
-                    const objectLiteral = {
-                        dataType: 'nestedObjectLiteral',
-                        properties,
-                    };
-                    const indexInfos = this.current.typeChecker.getIndexInfosOfType(type);
-                    const indexTypes = indexInfos.flatMap(indexInfo => {
-                        const typeNode = this.current.typeChecker.typeToTypeNode(indexInfo.type, undefined, ts.NodeBuilderFlags.NoTruncation);
-                        if (typeNode.kind === ts.SyntaxKind.NeverKeyword) {
-                            // { [k: string]: never; }
-                            return [];
-                        }
-                        const type = new TypeResolver(typeNode, this.current, mappedTypeNode, this.context, indexInfo.type).resolve();
-                        return [type];
-                    });
-                    if (indexTypes.length) {
-                        if (indexTypes.length === 1) {
-                            objectLiteral.additionalProperties = indexTypes[0];
-                        }
-                        else {
-                            // { [k: string]: string; } & { [k: number]: number; }
-                            // A | B is sometimes A type or B type, sometimes optionally accepts both A & B members.
-                            // Most people & TSOA thinks that A | B can be only A or only B.
-                            // So we can accept this merge
-                            //Every additional property key assumed as string
-                            objectLiteral.additionalProperties = {
-                                dataType: 'union',
-                                types: indexTypes,
-                            };
-                        }
-                    }
-                    return objectLiteral;
-                }
-                // Known issues & easy to implement: Partial<string>, Partial<never>, ... But I think a programmer not writes types like this
-                throw new exceptions_1.GenerateMetadataError(`Unhandled mapped type has found, flags: ${type.flags}`, this.typeNode);
-            };
-            const referencer = this.getReferencer();
-            const result = calcMappedType(referencer);
-            return result;
-        }
-        if (ts.isConditionalTypeNode(this.typeNode)) {
-            const referencer = this.getReferencer();
-            const resolvedNode = this.current.typeChecker.typeToTypeNode(referencer, undefined, ts.NodeBuilderFlags.NoTruncation);
-            return new TypeResolver(resolvedNode, this.current, this.typeNode, this.context, referencer).resolve();
-        }
-        // keyof & readonly arrays
-        if (ts.isTypeOperatorNode(this.typeNode)) {
-            return this.resolveTypeOperatorNode(this.typeNode, this.current.typeChecker, this.current, this.context, this.parentNode, this.referencer);
-        }
-        // Indexed type
-        if (ts.isIndexedAccessTypeNode(this.typeNode)) {
-            return this.resolveIndexedAccessTypeNode(this.typeNode, this.current.typeChecker, this.current, this.context);
-        }
-        if (ts.isTemplateLiteralTypeNode(this.typeNode)) {
-            const type = this.getReferencer();
-            (0, flowUtils_1.throwUnless)(type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral()), new exceptions_1.GenerateMetadataError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode));
-            // `a${'c' | 'd'}b`
-            const stringLiteralEnum = {
-                dataType: 'enum',
-                enums: type.types.map((stringLiteralType) => stringLiteralType.value),
+        // Known issues & easy to implement: Partial<string>, Partial<never>, ...
+        throw new exceptions_1.GenerateMetadataError(`Unhandled mapped type has found, flags: ${type.flags}`, this.typeNode);
+    }
+    resolveMappedObjectType(type, mappedTypeNode) {
+        const properties = type
+            .getProperties()
+            .filter(property => !this.isIgnoredMappedProperty(property))
+            .map(property => this.resolveMappedProperty(property));
+        const objectLiteral = {
+            dataType: 'nestedObjectLiteral',
+            properties,
+        };
+        const indexTypes = this.resolveMappedIndexTypes(type, mappedTypeNode);
+        if (indexTypes.length === 1) {
+            objectLiteral.additionalProperties = indexTypes[0];
+        }
+        else if (indexTypes.length > 1) {
+            objectLiteral.additionalProperties = {
+                dataType: 'union',
+                types: indexTypes,
             };
-            return stringLiteralEnum;
         }
-        if (ts.isParenthesizedTypeNode(this.typeNode)) {
-            return new TypeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
+        return objectLiteral;
+    }
+    resolveMappedProperty(property) {
+        const propertyType = this.current.typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
+        const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
+        const parent = this.getOriginalMappedDeclaration(property);
+        const comments = property.getDocumentationComment(this.current.typeChecker);
+        return {
+            name: property.getName(),
+            required: !this.hasFlag(property, ts.SymbolFlags.Optional),
+            deprecated: this.isDeprecatedMappedProperty(parent),
+            type: new TypeResolver(typeNode, this.current, parent, this.context, propertyType).resolve(),
+            default: this.getMappedPropertyDefault(parent),
+            validators: (parent ? (0, validatorUtils_1.getPropertyValidators)(parent) : {}) || {},
+            description: comments.length ? ts.displayPartsToString(comments) : undefined,
+            format: parent ? this.getNodeFormat(parent) : undefined,
+            example: parent ? this.getNodeExample(parent) : undefined,
+            extensions: parent ? this.getNodeExtension(parent) : undefined,
+        };
+    }
+    isDeprecatedMappedProperty(parent) {
+        if (!parent) {
+            return false;
+        }
+        return (0, jsDocUtils_1.isExistJSDocTag)(parent, tag => tag.tagName.text === 'deprecated') || (0, decoratorUtils_1.isDecorator)(parent, (_identifier, canonicalName) => canonicalName === 'Deprecated', this.current.typeChecker);
+    }
+    getMappedPropertyDefault(parent) {
+        if (!parent) {
+            return undefined;
+        }
+        if (hasInitializer(parent)) {
+            return (0, initializer_value_1.getInitializerValue)(parent.initializer, this.current.typeChecker);
         }
-        (0, flowUtils_1.throwUnless)(this.typeNode.kind === ts.SyntaxKind.TypeReference, new exceptions_1.GenerateMetadataError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode));
-        return this.resolveTypeReferenceNode(this.typeNode, this.current, this.context, this.parentNode);
+        return TypeResolver.getDefault(parent);
+    }
+    resolveMappedIndexTypes(type, mappedTypeNode) {
+        return this.current.typeChecker.getIndexInfosOfType(type).flatMap(indexInfo => {
+            const typeNode = this.current.typeChecker.typeToTypeNode(indexInfo.type, undefined, ts.NodeBuilderFlags.NoTruncation);
+            if (typeNode.kind === ts.SyntaxKind.NeverKeyword) {
+                return [];
+            }
+            return [new TypeResolver(typeNode, this.current, mappedTypeNode, this.context, indexInfo.type).resolve()];
+        });
+    }
+    resolveConditionalTypeNode() {
+        if (!ts.isConditionalTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        const referencer = this.getReferencer();
+        const resolvedNode = this.current.typeChecker.typeToTypeNode(referencer, undefined, ts.NodeBuilderFlags.NoTruncation);
+        return new TypeResolver(resolvedNode, this.current, this.typeNode, this.context, referencer).resolve();
+    }
+    resolveTypeOperatorTypeNode() {
+        if (!ts.isTypeOperatorNode(this.typeNode)) {
+            return undefined;
+        }
+        return this.resolveTypeOperatorNode(this.typeNode, this.current.typeChecker, this.current, this.context, this.parentNode, this.referencer);
+    }
+    resolveIndexedAccessTypeNodeWrapper() {
+        if (!ts.isIndexedAccessTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return this.resolveIndexedAccessTypeNode(this.typeNode, this.current.typeChecker, this.current, this.context);
+    }
+    resolveTemplateLiteralTypeNode() {
+        if (!ts.isTemplateLiteralTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        const type = this.getReferencer();
+        (0, flowUtils_1.throwUnless)(type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral()), new exceptions_1.GenerateMetadataError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode));
+        return {
+            dataType: 'enum',
+            enums: type.types.map((stringLiteralType) => stringLiteralType.value),
+        };
+    }
+    resolveParenthesizedTypeNode() {
+        if (!ts.isParenthesizedTypeNode(this.typeNode)) {
+            return undefined;
+        }
+        return new TypeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
     }
     resolveTypeOperatorNode(typeNode, typeChecker, current, context, parentNode, referencer) {
         switch (typeNode.operator) {
             case ts.SyntaxKind.KeyOfKeyword: {
-                // keyof
-                const type = typeChecker.getTypeFromTypeNode(typeNode);
-                if (type.isIndexType()) {
-                    // in case of generic: keyof T. Not handles all possible cases
-                    const symbol = type.type.getSymbol();
-                    if (symbol && symbol.getFlags() & ts.TypeFlags.TypeParameter) {
-                        const typeName = symbol.getEscapedName();
-                        (0, flowUtils_1.throwUnless)(typeof typeName === 'string', new exceptions_1.GenerateMetadataError(`typeName is not string, but ${typeof typeName}`, typeNode));
-                        if (context[typeName]) {
-                            const subResult = new TypeResolver(context[typeName].type, current, parentNode, context).resolve();
-                            if (subResult.dataType === 'any') {
-                                return {
-                                    dataType: 'union',
-                                    types: [{ dataType: 'string' }, { dataType: 'double' }],
-                                };
-                            }
-                            const properties = subResult.properties?.map(v => v.name);
-                            (0, flowUtils_1.throwUnless)(properties, new exceptions_1.GenerateMetadataError(`TypeOperator 'keyof' on node which have no properties`, context[typeName].type));
-                            return {
-                                dataType: 'enum',
-                                enums: properties,
-                            };
-                        }
-                    }
-                }
-                else if (type.isUnion()) {
-                    const literals = type.types.filter((t) => t.isLiteral());
-                    const literalValues = [];
-                    for (const literal of literals) {
-                        (0, flowUtils_1.throwUnless)(typeof literal.value == 'number' || typeof literal.value == 'string', new exceptions_1.GenerateMetadataError(`Not handled key Type, maybe ts.PseudoBigInt ${typeChecker.typeToString(literal)}`, typeNode));
-                        literalValues.push(literal.value);
-                    }
-                    if (!literals.length) {
-                        const length = type.types.length;
-                        const someStringFlag = type.types.some(t => t.flags === ts.TypeFlags.String);
-                        const someNumberFlag = type.types.some(t => t.flags === ts.TypeFlags.Number);
-                        const someSymbolFlag = type.types.some(t => t.flags === ts.TypeFlags.ESSymbol);
-                        if (someStringFlag && someNumberFlag) {
-                            if (length === 2 || (length === 3 && someSymbolFlag)) {
-                                return {
-                                    dataType: 'union',
-                                    types: [{ dataType: 'string' }, { dataType: 'double' }],
-                                };
-                            }
-                        }
-                    }
-                    // Warn on nonsense (`number`, `typeof Symbol.iterator`)
-                    if (type.types.some(t => !t.isLiteral())) {
-                        const problems = type.types.filter(t => !t.isLiteral()).map(t => typeChecker.typeToString(t));
-                        console.warn(new exceptions_1.GenerateMetaDataWarning(`Skipped non-literal type(s) ${problems.join(', ')}`, typeNode).toString());
-                    }
-                    const stringMembers = literalValues.filter(v => typeof v == 'string');
-                    const numberMembers = literalValues.filter(v => typeof v == 'number');
-                    if (stringMembers.length && numberMembers.length) {
-                        return {
-                            dataType: 'union',
-                            types: [
-                                { dataType: 'enum', enums: stringMembers },
-                                { dataType: 'enum', enums: numberMembers },
-                            ],
-                        };
-                    }
-                    return {
-                        dataType: 'enum',
-                        enums: literalValues,
-                    };
-                }
-                else if (type.isLiteral()) {
-                    (0, flowUtils_1.throwUnless)(typeof type.value == 'number' || typeof type.value == 'string', new exceptions_1.GenerateMetadataError(`Not handled indexType, maybe ts.PseudoBigInt ${typeChecker.typeToString(type)}`, typeNode));
-                    return {
-                        dataType: 'enum',
-                        enums: [type.value],
-                    };
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.Never)) {
-                    throw new exceptions_1.GenerateMetadataError(`TypeOperator 'keyof' on node produced a never type`, typeNode);
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.TemplateLiteral)) {
-                    //Now assumes template literals as string
-                    console.warn(new exceptions_1.GenerateMetaDataWarning(`Template literals are assumed as strings`, typeNode).toString());
-                    return {
-                        dataType: 'string',
-                    };
-                }
-                else if (this.hasFlag(type, ts.TypeFlags.Number)) {
-                    return {
-                        dataType: 'double',
-                    };
-                }
-                const indexedTypeName = typeChecker.typeToString(typeChecker.getTypeFromTypeNode(typeNode.type));
-                throw new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${indexedTypeName}`, typeNode);
+                return this.resolveKeyOfTypeOperator(typeNode, typeChecker, current, context, parentNode);
             }
             case ts.SyntaxKind.ReadonlyKeyword:
                 // Handle `readonly` arrays
@@ -521,46 +477,176 @@ class TypeResolver {
                 throw new exceptions_1.GenerateMetadataError(`Unknown type: ${ts.SyntaxKind[typeNode.kind]}`, typeNode);
         }
     }
+    resolveKeyOfTypeOperator(typeNode, typeChecker, current, context, parentNode) {
+        const type = typeChecker.getTypeFromTypeNode(typeNode);
+        const indexedType = this.resolveKeyOfIndexType(type, typeNode, current, context, parentNode);
+        if (indexedType) {
+            return indexedType;
+        }
+        if (type.isUnion()) {
+            return this.resolveKeyOfUnionType(type, typeNode, typeChecker);
+        }
+        if (type.isLiteral()) {
+            return this.resolveKeyOfLiteralType(type, typeNode, typeChecker);
+        }
+        return this.resolveFallbackKeyOfType(type, typeNode, typeChecker);
+    }
+    resolveKeyOfIndexType(type, typeNode, current, context, parentNode) {
+        if (!type.isIndexType()) {
+            return undefined;
+        }
+        const symbol = type.type.getSymbol();
+        if (!symbol || (symbol.getFlags() & ts.TypeFlags.TypeParameter) === 0) {
+            return undefined;
+        }
+        const typeName = symbol.getEscapedName();
+        (0, flowUtils_1.throwUnless)(typeof typeName === 'string', new exceptions_1.GenerateMetadataError(`typeName is not string, but ${typeof typeName}`, typeNode));
+        const contextualType = context[typeName];
+        if (!contextualType) {
+            return undefined;
+        }
+        const subResult = new TypeResolver(contextualType.type, current, parentNode, context).resolve();
+        if (subResult.dataType === 'any') {
+            return this.createStringAndNumberUnion();
+        }
+        const properties = subResult.properties?.map(property => property.name);
+        (0, flowUtils_1.throwUnless)(properties, new exceptions_1.GenerateMetadataError(`TypeOperator 'keyof' on node which have no properties`, contextualType.type));
+        return {
+            dataType: 'enum',
+            enums: properties,
+        };
+    }
+    resolveKeyOfUnionType(type, typeNode, typeChecker) {
+        const literals = type.types.filter((member) => member.isLiteral());
+        if (!literals.length) {
+            return this.resolveNonLiteralKeyOfUnionType(type, typeNode, typeChecker);
+        }
+        this.warnOnSkippedNonLiteralKeyTypes(type, typeNode, typeChecker);
+        return this.createLiteralKeyOfUnionType(literals, typeNode, typeChecker);
+    }
+    resolveNonLiteralKeyOfUnionType(type, typeNode, typeChecker) {
+        const typeFlags = new Set(type.types.map(member => member.flags));
+        const includesString = typeFlags.has(ts.TypeFlags.String);
+        const includesNumber = typeFlags.has(ts.TypeFlags.Number);
+        const includesSymbol = typeFlags.has(ts.TypeFlags.ESSymbol);
+        if (includesString && includesNumber && (type.types.length === 2 || (type.types.length === 3 && includesSymbol))) {
+            return this.createStringAndNumberUnion();
+        }
+        this.warnOnSkippedNonLiteralKeyTypes(type, typeNode, typeChecker);
+        return { dataType: 'enum', enums: [] };
+    }
+    warnOnSkippedNonLiteralKeyTypes(type, typeNode, typeChecker) {
+        const nonLiteralTypes = type.types.filter(member => !member.isLiteral());
+        if (!nonLiteralTypes.length) {
+            return;
+        }
+        const problems = nonLiteralTypes.map(member => typeChecker.typeToString(member));
+        console.warn(new exceptions_1.GenerateMetaDataWarning(`Skipped non-literal type(s) ${problems.join(', ')}`, typeNode).toString());
+    }
+    createLiteralKeyOfUnionType(literals, typeNode, typeChecker) {
+        const literalValues = literals.map(literal => this.getKeyLiteralValue(literal, typeNode, typeChecker));
+        const stringMembers = literalValues.filter((value) => typeof value === 'string');
+        const numberMembers = literalValues.filter((value) => typeof value === 'number');
+        if (stringMembers.length && numberMembers.length) {
+            return {
+                dataType: 'union',
+                types: [
+                    { dataType: 'enum', enums: stringMembers },
+                    { dataType: 'enum', enums: numberMembers },
+                ],
+            };
+        }
+        return {
+            dataType: 'enum',
+            enums: literalValues,
+        };
+    }
+    getKeyLiteralValue(literal, typeNode, typeChecker) {
+        (0, flowUtils_1.throwUnless)(typeof literal.value === 'number' || typeof literal.value === 'string', new exceptions_1.GenerateMetadataError(`Not handled key Type, maybe ts.PseudoBigInt ${typeChecker.typeToString(literal)}`, typeNode));
+        return literal.value;
+    }
+    resolveKeyOfLiteralType(type, typeNode, typeChecker) {
+        (0, flowUtils_1.throwUnless)(typeof type.value === 'number' || typeof type.value === 'string', new exceptions_1.GenerateMetadataError(`Not handled indexType, maybe ts.PseudoBigInt ${typeChecker.typeToString(type)}`, typeNode));
+        return {
+            dataType: 'enum',
+            enums: [type.value],
+        };
+    }
+    resolveFallbackKeyOfType(type, typeNode, typeChecker) {
+        if (this.hasFlag(type, ts.TypeFlags.Never)) {
+            throw new exceptions_1.GenerateMetadataError(`TypeOperator 'keyof' on node produced a never type`, typeNode);
+        }
+        if (this.hasFlag(type, ts.TypeFlags.TemplateLiteral)) {
+            console.warn(new exceptions_1.GenerateMetaDataWarning(`Template literals are assumed as strings`, typeNode).toString());
+            return { dataType: 'string' };
+        }
+        if (this.hasFlag(type, ts.TypeFlags.Number)) {
+            return { dataType: 'double' };
+        }
+        const indexedTypeName = typeChecker.typeToString(typeChecker.getTypeFromTypeNode(typeNode.type));
+        throw new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${indexedTypeName}`, typeNode);
+    }
+    createStringAndNumberUnion() {
+        return {
+            dataType: 'union',
+            types: [{ dataType: 'string' }, { dataType: 'double' }],
+        };
+    }
     resolveIndexedAccessTypeNode(typeNode, typeChecker, current, context) {
         const { indexType, objectType } = typeNode;
         if ([ts.SyntaxKind.NumberKeyword, ts.SyntaxKind.StringKeyword].includes(indexType.kind)) {
-            // Indexed by keyword
-            const isNumberIndexType = indexType.kind === ts.SyntaxKind.NumberKeyword;
-            const typeOfObjectType = typeChecker.getTypeFromTypeNode(objectType);
-            const type = isNumberIndexType ? typeOfObjectType.getNumberIndexType() : typeOfObjectType.getStringIndexType();
-            (0, flowUtils_1.throwUnless)(type, new exceptions_1.GenerateMetadataError(`Could not determine ${isNumberIndexType ? 'number' : 'string'} index on ${typeChecker.typeToString(typeOfObjectType)}`, typeNode));
-            return new TypeResolver(typeChecker.typeToTypeNode(type, objectType, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
-        }
-        else if (ts.isLiteralTypeNode(indexType) && (ts.isStringLiteral(indexType.literal) || ts.isNumericLiteral(indexType.literal))) {
-            // Indexed by literal
-            const hasType = (node) => node !== undefined && objectHasOwn(node, 'type');
-            const symbol = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(objectType), indexType.literal.text);
-            (0, flowUtils_1.throwUnless)(symbol, new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeChecker.typeToString(typeChecker.getTypeFromTypeNode(objectType))}`, typeNode));
-            if (hasType(symbol.valueDeclaration) && symbol.valueDeclaration.type) {
-                return new TypeResolver(symbol.valueDeclaration.type, current, typeNode, context).resolve();
-            }
-            const declaration = typeChecker.getTypeOfSymbolAtLocation(symbol, objectType);
-            try {
-                return new TypeResolver(typeChecker.typeToTypeNode(declaration, objectType, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
-            }
-            catch {
-                throw new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeChecker.typeToString(typeChecker.getTypeFromTypeNode(typeChecker.typeToTypeNode(declaration, undefined, ts.NodeBuilderFlags.NoTruncation)))}`, typeNode);
-            }
+            return this.resolveIndexedAccessKeywordType(typeNode, typeChecker, current, context, objectType, indexType);
+        }
+        if (ts.isLiteralTypeNode(indexType) && (ts.isStringLiteral(indexType.literal) || ts.isNumericLiteral(indexType.literal))) {
+            return this.resolveIndexedAccessLiteralType(typeNode, typeChecker, current, context, objectType, indexType);
         }
-        else if (ts.isTypeOperatorNode(indexType) && indexType.operator === ts.SyntaxKind.KeyOfKeyword) {
-            // Indexed by keyof typeof value
-            const typeOfObjectType = ts.isParenthesizedTypeNode(objectType) ? objectType.type : objectType;
-            const { type: typeOfIndexType } = indexType;
-            const isSameTypeQuery = ts.isTypeQueryNode(typeOfObjectType) && ts.isTypeQueryNode(typeOfIndexType) && typeOfObjectType.exprName.getText() === typeOfIndexType.exprName.getText();
-            const isSameTypeReference = ts.isTypeReferenceNode(typeOfObjectType) && ts.isTypeReferenceNode(typeOfIndexType) && typeOfObjectType.typeName.getText() === typeOfIndexType.typeName.getText();
-            if (isSameTypeQuery || isSameTypeReference) {
-                const type = this.getReferencer();
-                const node = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation);
-                return new TypeResolver(node, current, typeNode, context, this.referencer).resolve();
+        if (ts.isTypeOperatorNode(indexType) && indexType.operator === ts.SyntaxKind.KeyOfKeyword) {
+            const keyedIndexedAccessType = this.resolveKeyedIndexedAccessType(typeNode, typeChecker, current, context, objectType, indexType);
+            if (keyedIndexedAccessType) {
+                return keyedIndexedAccessType;
             }
         }
         throw new exceptions_1.GenerateMetadataError(`Unknown type: ${ts.SyntaxKind[typeNode.kind]}`, typeNode);
     }
+    resolveIndexedAccessKeywordType(typeNode, typeChecker, current, context, objectType, indexType) {
+        const isNumberIndexType = indexType.kind === ts.SyntaxKind.NumberKeyword;
+        const typeOfObjectType = typeChecker.getTypeFromTypeNode(objectType);
+        const indexedType = isNumberIndexType ? typeOfObjectType.getNumberIndexType() : typeOfObjectType.getStringIndexType();
+        (0, flowUtils_1.throwUnless)(indexedType, new exceptions_1.GenerateMetadataError(`Could not determine ${isNumberIndexType ? 'number' : 'string'} index on ${typeChecker.typeToString(typeOfObjectType)}`, typeNode));
+        return new TypeResolver(typeChecker.typeToTypeNode(indexedType, objectType, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
+    }
+    resolveIndexedAccessLiteralType(typeNode, typeChecker, current, context, objectType, indexType) {
+        const propertyName = ts.isStringLiteral(indexType.literal) || ts.isNumericLiteral(indexType.literal) ? indexType.literal.text : indexType.literal.getText();
+        const symbol = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(objectType), propertyName);
+        (0, flowUtils_1.throwUnless)(symbol, new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeChecker.typeToString(typeChecker.getTypeFromTypeNode(objectType))}`, typeNode));
+        if (this.symbolHasTypeDeclaration(symbol.valueDeclaration)) {
+            return new TypeResolver(symbol.valueDeclaration.type, current, typeNode, context).resolve();
+        }
+        const declarationType = typeChecker.getTypeOfSymbolAtLocation(symbol, objectType);
+        try {
+            return new TypeResolver(typeChecker.typeToTypeNode(declarationType, objectType, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
+        }
+        catch {
+            const typeNodeForError = typeChecker.typeToTypeNode(declarationType, undefined, ts.NodeBuilderFlags.NoTruncation);
+            const typeName = typeChecker.typeToString(typeChecker.getTypeFromTypeNode(typeNodeForError));
+            throw new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeName}`, typeNode);
+        }
+    }
+    symbolHasTypeDeclaration(node) {
+        return node !== undefined && objectHasOwn(node, 'type') && node.type !== undefined;
+    }
+    resolveKeyedIndexedAccessType(typeNode, typeChecker, current, context, objectType, indexType) {
+        const typeOfObjectType = ts.isParenthesizedTypeNode(objectType) ? objectType.type : objectType;
+        const typeOfIndexType = indexType.type;
+        const isSameTypeQuery = ts.isTypeQueryNode(typeOfObjectType) && ts.isTypeQueryNode(typeOfIndexType) && typeOfObjectType.exprName.getText() === typeOfIndexType.exprName.getText();
+        const isSameTypeReference = ts.isTypeReferenceNode(typeOfObjectType) && ts.isTypeReferenceNode(typeOfIndexType) && typeOfObjectType.typeName.getText() === typeOfIndexType.typeName.getText();
+        if (!isSameTypeQuery && !isSameTypeReference) {
+            return undefined;
+        }
+        const type = this.getReferencer();
+        const node = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation);
+        return new TypeResolver(node, current, typeNode, context, this.referencer).resolve();
+    }
     resolveTypeReferenceNode(typeNode, current, context, parentNode) {
         const { typeName } = typeNode;
         const resolvedTypeArguments = typeNode.typeArguments ? [...typeNode.typeArguments] : undefined;
@@ -772,92 +858,83 @@ class TypeResolver {
     }
     //Generates type name for type references
     calcRefTypeName(type) {
-        const getEntityName = (type) => {
-            if (ts.isIdentifier(type)) {
-                return type.text;
-            }
-            return `${getEntityName(type.left)}.${type.right.text}`;
-        };
-        let name = getEntityName(type);
-        if (this.context[name]) {
-            //resolve name only interesting if entity is not qualifiedName
-            name = this.context[name].name; //Not needed to check unicity, because generic parameters are checked previously
+        const contextualName = this.context[this.getEntityNameText(type)]?.name;
+        if (contextualName) {
+            return contextualName;
+        }
+        const declarations = this.getModelTypeDeclarations(type);
+        if (!declarations.length) {
+            return this.getFallbackRefTypeName(type);
+        }
+        const name = this.getDeclarationBasedRefTypeName(type, declarations);
+        this.current.CheckModelUnicity(name, declarations.map(declaration => ({
+            fileName: declaration.getSourceFile().fileName,
+            pos: declaration.pos,
+        })));
+        return name;
+    }
+    getEntityNameText(type) {
+        if (ts.isIdentifier(type)) {
+            return type.text;
         }
-        else {
-            const declarations = this.getModelTypeDeclarations(type);
-            // Handle cases where declarations is empty (e.g., inline object types in generics)
-            if (!declarations || declarations.length === 0) {
-                // Check if this is a simple identifier (like Date, String, etc.)
-                if (ts.isIdentifier(type)) {
-                    // For simple identifiers, just return the name
-                    return type.text;
-                }
-                // For inline object types, we should use the resolve method to get the proper type
-                // This will handle TypeLiteralNode, UnionTypeNode, etc. properly
-                // Note: We need to cast to TypeNode since EntityName can be Identifier or QualifiedName
-                const typeNode = type;
-                const resolvedType = new TypeResolver(typeNode, this.current, this.parentNode, this.context).resolve();
-                // Generate a deterministic name for this inline type based on its structure
-                const typeName = this.calcTypeName(typeNode);
-                const sanitizedName = typeName
-                    .replace(/[^A-Za-z0-9]/g, '_')
-                    .replace(/_+/g, '_')
-                    .replace(/^_|_$/g, '');
-                const uniqueName = `Inline_${sanitizedName}`;
-                // Add to reference types so it can be properly serialized
-                // We need to create a proper ReferenceType object
-                const referenceType = {
-                    dataType: 'refAlias',
-                    refName: uniqueName,
-                    type: resolvedType,
-                    validators: {},
-                    deprecated: false,
-                };
-                this.current.AddReferenceType(referenceType);
-                return uniqueName;
-            }
-            //Two possible solutions for recognizing different types:
-            // - Add declaration positions into type names (In an order).
-            //    - It accepts multiple types with same name, if the code compiles, there would be no conflicts in the type names
-            //    - Clear namespaces from type names.
-            //    - Horrible changes can be in the routes.ts in case of teamwork,
-            //        because source files have paths in the computer where data generation runs.
-            // - Use fully namespaced names
-            //    - Conflicts can be recognized because of the declarations
-            //
-            // The second was implemented, it not changes the usual type name formats.
-            const oneDeclaration = declarations[0]; //Every declarations should be in the same namespace hierarchy
-            if (oneDeclaration && ts.isEnumMember(oneDeclaration)) {
-                name = `${oneDeclaration.parent.name.getText()}.${oneDeclaration.name.getText()}`;
-            }
-            else {
-                name = oneDeclaration.name?.getText() || name;
+        return `${this.getEntityNameText(type.left)}.${type.right.text}`;
+    }
+    getFallbackRefTypeName(type) {
+        if (ts.isIdentifier(type)) {
+            return type.text;
+        }
+        return this.createInlineReferenceTypeName(type);
+    }
+    createInlineReferenceTypeName(typeNode) {
+        const resolvedType = new TypeResolver(typeNode, this.current, this.parentNode, this.context).resolve();
+        const uniqueName = `Inline_${this.sanitizeInlineTypeName(this.calcTypeName(typeNode))}`;
+        this.current.AddReferenceType({
+            dataType: 'refAlias',
+            refName: uniqueName,
+            type: resolvedType,
+            validators: {},
+            deprecated: false,
+        });
+        return uniqueName;
+    }
+    sanitizeInlineTypeName(typeName) {
+        return typeName
+            .replaceAll(/[^A-Za-z0-9]/g, '_')
+            .replaceAll(/_+/g, '_')
+            .replaceAll(/^_+|_+$/g, '');
+    }
+    getDeclarationBasedRefTypeName(type, declarations) {
+        const declaration = declarations[0];
+        let name = this.getDeclarationRefTypeName(declaration, this.getEntityNameText(type));
+        let currentNode = declaration.parent;
+        let isFirst = true;
+        while (!ts.isSourceFile(currentNode)) {
+            if (ts.isBlock(currentNode)) {
+                break;
             }
-            let actNode = oneDeclaration.parent;
-            let isFirst = true;
-            const isGlobalDeclaration = (mod) => mod.name.kind === ts.SyntaxKind.Identifier && mod.name.text === 'global';
-            while (!ts.isSourceFile(actNode)) {
-                if (ts.isBlock(actNode)) {
-                    break;
-                }
-                if (!(isFirst && ts.isEnumDeclaration(actNode)) && !ts.isModuleBlock(actNode)) {
-                    (0, flowUtils_1.throwUnless)(ts.isModuleDeclaration(actNode), new exceptions_1.GenerateMetadataError(`This node kind is unknown: ${actNode.kind}`, type));
-                    if (!isGlobalDeclaration(actNode)) {
-                        const moduleName = actNode.name.text;
-                        name = `${moduleName}.${name}`;
-                    }
+            if (this.shouldPrefixDeclarationNamespace(currentNode, isFirst)) {
+                (0, flowUtils_1.throwUnless)(ts.isModuleDeclaration(currentNode), new exceptions_1.GenerateMetadataError(`This node kind is unknown: ${currentNode.kind}`, type));
+                if (!this.isGlobalDeclaration(currentNode)) {
+                    name = `${currentNode.name.text}.${name}`;
                 }
-                isFirst = false;
-                actNode = actNode.parent;
             }
-            const declarationPositions = declarations.map(declaration => ({
-                fileName: declaration.getSourceFile().fileName,
-                pos: declaration.pos,
-            }));
-            this.current.CheckModelUnicity(name, declarationPositions);
+            isFirst = false;
+            currentNode = currentNode.parent;
         }
         return name;
     }
+    getDeclarationRefTypeName(declaration, fallbackName) {
+        if (ts.isEnumMember(declaration)) {
+            return `${declaration.parent.name.getText()}.${declaration.name.getText()}`;
+        }
+        return declaration.name?.getText() ?? fallbackName;
+    }
+    shouldPrefixDeclarationNamespace(node, isFirst) {
+        return !(isFirst && ts.isEnumDeclaration(node)) && !ts.isModuleBlock(node);
+    }
+    isGlobalDeclaration(node) {
+        return node.name.kind === ts.SyntaxKind.Identifier && node.name.text === 'global';
+    }
     calcMemberJsDocProperties(arg) {
         const def = TypeResolver.getDefault(arg);
         const isDeprecated = (0, jsDocUtils_1.isExistJSDocTag)(arg, tag => tag.tagName.text === 'deprecated') || (0, decoratorUtils_1.isDecorator)(arg, (_identifier, canonicalName) => canonicalName === 'Deprecated', this.current.typeChecker);
@@ -874,7 +951,7 @@ class TypeResolver {
             description,
             validators: validators && Object.keys(validators).length ? validators : undefined,
             format,
-            example: example !== undefined ? example : undefined,
+            example,
             extensions: extensions.length ? extensions : undefined,
             deprecated: isDeprecated ? true : undefined,
             ignored: isIgnored ? true : undefined,
@@ -892,103 +969,131 @@ class TypeResolver {
     }
     //Generates type name for type references
     calcTypeName(arg) {
-        if (ts.isLiteralTypeNode(arg)) {
-            const literalValue = this.getLiteralValue(arg);
-            if (typeof literalValue == 'string') {
-                return `'${literalValue}'`;
-            }
-            if (literalValue === null) {
-                return 'null';
-            }
-            if (typeof literalValue === 'boolean') {
-                return literalValue === true ? 'true' : 'false';
-            }
-            return `${literalValue}`;
+        const literalTypeName = this.getLiteralTypeName(arg);
+        if (literalTypeName) {
+            return literalTypeName;
         }
         const resolvedType = primitiveTransformer_1.PrimitiveTransformer.resolveKindToPrimitive(arg.kind);
         if (resolvedType) {
             return resolvedType;
         }
-        if (ts.isTypeReferenceNode(arg) || ts.isExpressionWithTypeArguments(arg)) {
-            return this.calcTypeReferenceTypeName(arg)[1];
+        const structuralTypeName = this.getStructuralTypeName(arg);
+        if (structuralTypeName) {
+            return structuralTypeName;
         }
-        else if (ts.isTypeLiteralNode(arg)) {
-            const members = arg.members.map(member => {
-                if (ts.isPropertySignature(member)) {
-                    const name = member.name.text;
-                    const typeText = this.calcTypeName(member.type);
-                    return `"${name}"${member.questionToken ? '?' : ''}${this.calcMemberJsDocProperties(member)}: ${typeText}`;
-                }
-                else if (ts.isIndexSignatureDeclaration(member)) {
-                    (0, flowUtils_1.throwUnless)(member.parameters.length === 1, new exceptions_1.GenerateMetadataError(`Index signature parameters length != 1`, member));
-                    const indexType = member.parameters[0];
-                    (0, flowUtils_1.throwUnless)(
-                    // now we can't reach this part of code
-                    ts.isParameter(indexType), new exceptions_1.GenerateMetadataError(`indexSignature declaration parameter kind is not SyntaxKind.Parameter`, indexType));
-                    (0, flowUtils_1.throwUnless)(!indexType.questionToken, new exceptions_1.GenerateMetadataError(`Question token has found for an indexSignature declaration`, indexType));
-                    const typeText = this.calcTypeName(member.type);
-                    const indexName = indexType.name.text;
-                    const indexTypeText = this.calcTypeName(indexType.type);
-                    return `["${indexName}": ${indexTypeText}]: ${typeText}`;
-                }
-                throw new exceptions_1.GenerateMetadataError(`Unhandled member kind has found: ${member.kind}`, member);
-            });
-            return `{${members.join('; ')}}`;
+        console.warn(new exceptions_1.GenerateMetaDataWarning(`This kind (${arg.kind}) is unhandled, so the type will be any, and no type conflict checks will made`, arg).toString());
+        return 'any';
+    }
+    getLiteralTypeName(arg) {
+        if (!ts.isLiteralTypeNode(arg)) {
+            return undefined;
         }
-        else if (ts.isArrayTypeNode(arg)) {
-            const typeName = this.calcTypeName(arg.elementType);
-            return `${typeName}[]`;
+        const literalValue = this.getLiteralValue(arg);
+        if (typeof literalValue === 'string') {
+            return `'${literalValue}'`;
         }
-        else if (ts.isIntersectionTypeNode(arg)) {
-            const memberTypeNames = arg.types.map(type => this.calcTypeName(type));
-            return memberTypeNames.join(' & ');
+        if (literalValue === null) {
+            return 'null';
         }
-        else if (ts.isUnionTypeNode(arg)) {
-            const memberTypeNames = arg.types.map(type => this.calcTypeName(type));
-            return memberTypeNames.join(' | ');
+        if (typeof literalValue === 'boolean') {
+            return literalValue ? 'true' : 'false';
         }
-        else if (ts.isTypeOperatorNode(arg)) {
-            const subTypeName = this.calcTypeName(arg.type);
-            if (arg.operator === ts.SyntaxKind.KeyOfKeyword) {
-                return `keyof ${subTypeName}`;
-            }
-            else if (arg.operator === ts.SyntaxKind.ReadonlyKeyword) {
-                return `readonly ${subTypeName}`;
-            }
-            throw new exceptions_1.GenerateMetadataError(`Unknown keyword has found: ${arg.operator}`, arg);
+        return `${literalValue}`;
+    }
+    getStructuralTypeName(arg) {
+        return (this.getReferenceLikeTypeName(arg) ??
+            this.getTypeLiteralName(arg) ??
+            this.getArrayTypeName(arg) ??
+            this.getIntersectionTypeName(arg) ??
+            this.getUnionTypeName(arg) ??
+            this.getTypeOperatorTypeName(arg) ??
+            this.getTypeQueryName(arg) ??
+            this.getIndexedAccessTypeName(arg) ??
+            this.getKeywordTypeName(arg) ??
+            this.getConditionalTypeName(arg) ??
+            this.getParenthesizedTypeName(arg));
+    }
+    getReferenceLikeTypeName(arg) {
+        if (!ts.isTypeReferenceNode(arg) && !ts.isExpressionWithTypeArguments(arg)) {
+            return undefined;
         }
-        else if (ts.isTypeQueryNode(arg)) {
-            const subTypeName = this.calcRefTypeName(arg.exprName);
-            return `typeof ${subTypeName}`;
+        return this.calcTypeReferenceTypeName(arg)[1];
+    }
+    getTypeLiteralName(arg) {
+        if (!ts.isTypeLiteralNode(arg)) {
+            return undefined;
         }
-        else if (ts.isIndexedAccessTypeNode(arg)) {
-            const objectTypeName = this.calcTypeName(arg.objectType);
-            const indexTypeName = this.calcTypeName(arg.indexType);
-            return `${objectTypeName}[${indexTypeName}]`;
+        return `{${arg.members.map(member => this.getTypeLiteralMemberName(member)).join('; ')}}`;
+    }
+    getTypeLiteralMemberName(member) {
+        if (ts.isPropertySignature(member)) {
+            const name = member.name.text;
+            const typeText = this.calcTypeName(member.type);
+            return `"${name}"${member.questionToken ? '?' : ''}${this.calcMemberJsDocProperties(member)}: ${typeText}`;
         }
-        else if (arg.kind === ts.SyntaxKind.UnknownKeyword) {
-            return 'unknown';
+        if (ts.isIndexSignatureDeclaration(member)) {
+            return this.getIndexSignatureTypeName(member);
         }
-        else if (arg.kind === ts.SyntaxKind.AnyKeyword) {
-            return 'any';
+        throw new exceptions_1.GenerateMetadataError(`Unhandled member kind has found: ${member.kind}`, member);
+    }
+    getIndexSignatureTypeName(member) {
+        (0, flowUtils_1.throwUnless)(member.parameters.length === 1, new exceptions_1.GenerateMetadataError(`Index signature parameters length != 1`, member));
+        const indexType = member.parameters[0];
+        (0, flowUtils_1.throwUnless)(ts.isParameter(indexType), new exceptions_1.GenerateMetadataError(`indexSignature declaration parameter kind is not SyntaxKind.Parameter`, indexType));
+        (0, flowUtils_1.throwUnless)(!indexType.questionToken, new exceptions_1.GenerateMetadataError(`Question token has found for an indexSignature declaration`, indexType));
+        const indexName = indexType.name.text;
+        const indexTypeText = this.calcTypeName(indexType.type);
+        return `["${indexName}": ${indexTypeText}]: ${this.calcTypeName(member.type)}`;
+    }
+    getArrayTypeName(arg) {
+        return ts.isArrayTypeNode(arg) ? `${this.calcTypeName(arg.elementType)}[]` : undefined;
+    }
+    getIntersectionTypeName(arg) {
+        return ts.isIntersectionTypeNode(arg) ? arg.types.map(type => this.calcTypeName(type)).join(' & ') : undefined;
+    }
+    getUnionTypeName(arg) {
+        return ts.isUnionTypeNode(arg) ? arg.types.map(type => this.calcTypeName(type)).join(' | ') : undefined;
+    }
+    getTypeOperatorTypeName(arg) {
+        if (!ts.isTypeOperatorNode(arg)) {
+            return undefined;
         }
-        else if (arg.kind === ts.SyntaxKind.NeverKeyword) {
-            return 'never';
+        const subTypeName = this.calcTypeName(arg.type);
+        if (arg.operator === ts.SyntaxKind.KeyOfKeyword) {
+            return `keyof ${subTypeName}`;
         }
-        else if (ts.isConditionalTypeNode(arg)) {
-            const checkTypeName = this.calcTypeName(arg.checkType);
-            const extendsTypeName = this.calcTypeName(arg.extendsType);
-            const trueTypeName = this.calcTypeName(arg.trueType);
-            const falseTypeName = this.calcTypeName(arg.falseType);
-            return `${checkTypeName} extends ${extendsTypeName} ? ${trueTypeName} : ${falseTypeName}`;
+        if (arg.operator === ts.SyntaxKind.ReadonlyKeyword) {
+            return `readonly ${subTypeName}`;
         }
-        else if (ts.isParenthesizedTypeNode(arg)) {
-            const internalTypeName = this.calcTypeName(arg.type);
-            return `(${internalTypeName})`; //Parentheses are not really interesting. The type name generation adds parentheses for the clarity
+        throw new exceptions_1.GenerateMetadataError(`Unknown keyword has found: ${arg.operator}`, arg);
+    }
+    getTypeQueryName(arg) {
+        return ts.isTypeQueryNode(arg) ? `typeof ${this.calcRefTypeName(arg.exprName)}` : undefined;
+    }
+    getIndexedAccessTypeName(arg) {
+        return ts.isIndexedAccessTypeNode(arg) ? `${this.calcTypeName(arg.objectType)}[${this.calcTypeName(arg.indexType)}]` : undefined;
+    }
+    getKeywordTypeName(arg) {
+        if (arg.kind === ts.SyntaxKind.UnknownKeyword) {
+            return 'unknown';
         }
-        const warning = new exceptions_1.GenerateMetaDataWarning(`This kind (${arg.kind}) is unhandled, so the type will be any, and no type conflict checks will made`, arg);
-        console.warn(warning.toString());
-        return 'any';
+        if (arg.kind === ts.SyntaxKind.AnyKeyword) {
+            return 'any';
+        }
+        return arg.kind === ts.SyntaxKind.NeverKeyword ? 'never' : undefined;
+    }
+    getConditionalTypeName(arg) {
+        if (!ts.isConditionalTypeNode(arg)) {
+            return undefined;
+        }
+        const checkTypeName = this.calcTypeName(arg.checkType);
+        const extendsTypeName = this.calcTypeName(arg.extendsType);
+        const trueTypeName = this.calcTypeName(arg.trueType);
+        const falseTypeName = this.calcTypeName(arg.falseType);
+        return `${checkTypeName} extends ${extendsTypeName} ? ${trueTypeName} : ${falseTypeName}`;
+    }
+    getParenthesizedTypeName(arg) {
+        return ts.isParenthesizedTypeNode(arg) ? `(${this.calcTypeName(arg.type)})` : undefined;
     }
     //Generates type name for type references
     calcTypeReferenceTypeName(node) {
@@ -1006,54 +1111,53 @@ class TypeResolver {
         const refTypeName = this.getRefTypeName(name);
         this.current.CheckExpressionUnicity(refTypeName, name);
         this.context = this.typeArgumentsToContext(node, type);
-        const calcReferenceType = () => {
-            try {
-                const existingType = localReferenceTypeCache[name];
-                if (existingType) {
-                    return existingType;
-                }
-                if (inProgressTypes[name]) {
-                    return this.createCircularDependencyResolver(name, refTypeName);
-                }
-                inProgressTypes[name] = [];
-                const declarations = this.getModelTypeDeclarations(type);
-                const referenceTypes = [];
-                // If no declarations found, this might be a built-in type or a type that can't be resolved
-                if (declarations.length === 0) {
-                    const fallbackReferenceType = this.getReferenceTypeFromTypeChecker(node, name, refTypeName);
-                    if (fallbackReferenceType) {
-                        this.addToLocalReferenceTypeCache(name, fallbackReferenceType);
-                        return fallbackReferenceType;
-                    }
-                    throw new exceptions_1.GenerateMetadataError(`Could not find declarations for type '${name}'. This might be a complex generic type that needs special handling.`);
-                }
-                for (const declaration of declarations) {
-                    if (ts.isTypeAliasDeclaration(declaration)) {
-                        const referencer = node.pos !== -1 ? this.current.typeChecker.getTypeFromTypeNode(node) : undefined;
-                        referenceTypes.push(new referenceTransformer_1.ReferenceTransformer().transform(declaration, refTypeName, this, referencer));
-                    }
-                    else if (enumTransformer_1.EnumTransformer.transformable(declaration)) {
-                        referenceTypes.push(new enumTransformer_1.EnumTransformer().transform(this, declaration, refTypeName));
-                    }
-                    else {
-                        referenceTypes.push(this.getModelReference(declaration, refTypeName));
-                    }
-                }
-                const referenceType = referenceTransformer_1.ReferenceTransformer.merge(referenceTypes);
-                this.addToLocalReferenceTypeCache(name, referenceType);
-                return referenceType;
-            }
-            catch (err) {
-                delete inProgressTypes[name];
-                throw err;
-            }
-        };
-        const result = calcReferenceType();
+        const result = this.resolveReferenceType(node, type, name, refTypeName);
         if (addToRefTypeMap) {
             this.current.AddReferenceType(result);
         }
         return result;
     }
+    resolveReferenceType(node, type, name, refTypeName) {
+        try {
+            const existingType = localReferenceTypeCache[name];
+            if (existingType) {
+                return existingType;
+            }
+            if (inProgressTypes[name]) {
+                return this.createCircularDependencyResolver(name, refTypeName);
+            }
+            inProgressTypes[name] = [];
+            const declarations = this.getModelTypeDeclarations(type);
+            if (!declarations.length) {
+                return this.resolveReferenceTypeFallback(node, name, refTypeName);
+            }
+            const referenceType = referenceTransformer_1.ReferenceTransformer.merge(declarations.map(declaration => this.resolveDeclarationReferenceType(declaration, node, refTypeName)));
+            this.addToLocalReferenceTypeCache(name, referenceType);
+            return referenceType;
+        }
+        catch (error) {
+            delete inProgressTypes[name];
+            throw error;
+        }
+    }
+    resolveReferenceTypeFallback(node, name, refTypeName) {
+        const fallbackReferenceType = this.getReferenceTypeFromTypeChecker(node, name, refTypeName);
+        if (fallbackReferenceType) {
+            this.addToLocalReferenceTypeCache(name, fallbackReferenceType);
+            return fallbackReferenceType;
+        }
+        throw new exceptions_1.GenerateMetadataError(`Could not find declarations for type '${name}'. This might be a complex generic type that needs special handling.`);
+    }
+    resolveDeclarationReferenceType(declaration, node, refTypeName) {
+        if (ts.isTypeAliasDeclaration(declaration)) {
+            const referencer = node.pos !== -1 ? this.current.typeChecker.getTypeFromTypeNode(node) : undefined;
+            return new referenceTransformer_1.ReferenceTransformer().transform(declaration, refTypeName, this, referencer);
+        }
+        if (enumTransformer_1.EnumTransformer.transformable(declaration)) {
+            return new enumTransformer_1.EnumTransformer().transform(this, declaration, refTypeName);
+        }
+        return this.getModelReference(declaration, refTypeName);
+    }
     addToLocalReferenceTypeCache(name, refType) {
         if (inProgressTypes[name]) {
             for (const fn of inProgressTypes[name]) {
@@ -1071,62 +1175,65 @@ class TypeResolver {
         // Handle toJSON methods
         (0, flowUtils_1.throwUnless)(modelType.name, new exceptions_1.GenerateMetadataError("Can't get Symbol from anonymous class", modelType));
         const type = this.current.typeChecker.getTypeAtLocation(modelType.name);
-        const toJSON = this.current.typeChecker.getPropertyOfType(type, 'toJSON');
-        if (toJSON && toJSON.valueDeclaration && (ts.isMethodDeclaration(toJSON.valueDeclaration) || ts.isMethodSignature(toJSON.valueDeclaration))) {
-            let nodeType = toJSON.valueDeclaration.type;
+        const toJSONDeclaration = this.current.typeChecker.getPropertyOfType(type, 'toJSON')?.valueDeclaration;
+        if (toJSONDeclaration && (ts.isMethodDeclaration(toJSONDeclaration) || ts.isMethodSignature(toJSONDeclaration))) {
+            let nodeType = toJSONDeclaration.type;
             if (!nodeType) {
-                const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
+                const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSONDeclaration);
                 const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
                 nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
             }
-            const type = new TypeResolver(nodeType, this.current).resolve();
-            const referenceType = {
+            return this.withDefinedReferenceMetadata({
                 refName: refTypeName,
                 dataType: 'refAlias',
                 description,
-                type,
+                type: new TypeResolver(nodeType, this.current).resolve(),
                 validators: {},
                 deprecated,
-                ...(example !== undefined ? { example } : {}),
-                ...(title !== undefined ? { title } : {}),
-            };
-            return referenceType;
+            }, { example, title });
         }
         const properties = new propertyTransformer_1.PropertyTransformer().transform(this, modelType);
         const additionalProperties = this.getModelAdditionalProperties(modelType);
         const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
-        const referenceType = {
+        const referenceType = this.withDefinedReferenceMetadata({
             additionalProperties,
             dataType: 'refObject',
             description,
             properties: inheritedProperties,
             refName: refTypeName,
             deprecated,
-            ...(example !== undefined ? { example } : {}),
-            ...(title !== undefined ? { title } : {}),
-        };
+        }, { example, title });
         referenceType.properties = referenceType.properties.concat(properties);
         return referenceType;
     }
+    withDefinedReferenceMetadata(referenceType, metadata) {
+        if (metadata.example !== undefined) {
+            referenceType.example = metadata.example;
+        }
+        if (metadata.title !== undefined) {
+            referenceType.title = metadata.title;
+        }
+        return referenceType;
+    }
     //Generates a name from the original type expression.
     //This function is not invertable, so it's possible, that 2 type expressions have the same refTypeName.
     getRefTypeName(name) {
         let preformattedName = name //Preformatted name handles most cases
             .replaceAll('<', '_')
             .replaceAll('>', '_')
-            .replace(/\s+/g, '')
+            .replaceAll(/\s+/g, '')
             .replaceAll(',', '.')
-            .replace(/'([^']*)'/g, '$1')
-            .replace(/"([^"]*)"/g, '$1')
+            .replaceAll(/'([^']*)'/g, '$1')
+            .replaceAll(/"([^"]*)"/g, '$1')
             .replaceAll('&', '-and-')
             .replaceAll('|', '-or-')
             .replaceAll('[]', '-Array')
             .replaceAll(/[{}]/g, '_'); // SuccessResponse_{indexesCreated-number}_ -> SuccessResponse__indexesCreated-number__
         preformattedName = replaceTypeLiteralPropertySeparators(preformattedName); // SuccessResponse_indexesCreated:number_ -> SuccessResponse_indexesCreated-number_
-        preformattedName = preformattedName.replace(/;/g, '--');
+        preformattedName = preformattedName.replaceAll(';', '--');
         preformattedName = replaceIndexedAccessSegments(preformattedName); // Partial_SerializedDatasourceWithVersion[format]_ -> Partial_SerializedDatasourceWithVersion~format~_,
         //Safety fixes to replace all characters which are not accepted by swagger ui
-        let formattedName = preformattedName.replace(/[^A-Za-z0-9\-._]/g, match => {
+        let formattedName = preformattedName.replaceAll(/[^A-Za-z0-9\-._]/g, match => {
             return `_${match.codePointAt(0) ?? 0}_`;
         });
         formattedName = formattedName.replaceAll('92_r_92_n', '92_n'); //Windows uses \r\n, but linux uses \n.
@@ -1423,66 +1530,123 @@ class TypeResolver {
     }
     static getDefault(node) {
         const defaultStr = (0, jsDocUtils_1.getJSDocComment)(node, 'default');
-        if (typeof defaultStr == 'string' && defaultStr !== 'undefined') {
-            let textStartCharacter = undefined;
-            const inString = () => textStartCharacter !== undefined;
-            let formattedStr = '';
-            for (let i = 0; i < defaultStr.length; ++i) {
-                const actCharacter = defaultStr[i];
-                if (inString()) {
-                    if (actCharacter === textStartCharacter) {
-                        formattedStr += '"';
-                        textStartCharacter = undefined;
-                    }
-                    else if (actCharacter === '"') {
-                        formattedStr += '\\"';
-                    }
-                    else if (actCharacter === '\\') {
-                        ++i;
-                        if (i < defaultStr.length) {
-                            const nextCharacter = defaultStr[i];
-                            if (['n', 't', 'r', 'b', 'f', '\\', '"'].includes(nextCharacter)) {
-                                formattedStr += '\\' + nextCharacter;
-                            }
-                            else if (!['v', '0'].includes(nextCharacter)) {
-                                //\v, \0 characters are not compatible with JSON
-                                formattedStr += nextCharacter;
-                            }
-                        }
-                        else {
-                            formattedStr += actCharacter; // this is a bug, but let the JSON parser decide how to handle it
-                        }
-                    }
-                    else {
-                        formattedStr += actCharacter;
-                    }
-                }
-                else {
-                    if ([`"`, "'", '`'].includes(actCharacter)) {
-                        textStartCharacter = actCharacter;
-                        formattedStr += '"';
-                    }
-                    else if (actCharacter === '/' && i + 1 < defaultStr.length && defaultStr[i + 1] === '/') {
-                        i += 2;
-                        while (i < defaultStr.length && defaultStr[i] !== '\n') {
-                            ++i;
-                        }
-                    }
-                    else {
-                        formattedStr += actCharacter;
-                    }
-                }
-            }
-            try {
-                const parsed = JSON.parse(formattedStr);
-                return parsed;
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : '-';
-                throw new exceptions_1.GenerateMetadataError(`JSON could not parse default str: "${defaultStr}", preformatted: "${formattedStr}"\nmessage: "${message}"`);
-            }
+        if (typeof defaultStr !== 'string' || defaultStr === 'undefined') {
+            return undefined;
         }
-        return undefined;
+        const formattedStr = this.formatDefaultString(defaultStr);
+        try {
+            return JSON.parse(formattedStr);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : '-';
+            throw new exceptions_1.GenerateMetadataError(`JSON could not parse default str: "${defaultStr}", preformatted: "${formattedStr}"\nmessage: "${message}"`);
+        }
+    }
+    static formatDefaultString(defaultStr) {
+        const initialState = { formatted: '' };
+        let state = initialState;
+        let index = 0;
+        while (index < defaultStr.length) {
+            const formattedCharacter = this.formatDefaultCharacter(defaultStr, index, state);
+            state = {
+                formatted: formattedCharacter.formatted,
+                textStartCharacter: formattedCharacter.textStartCharacter,
+            };
+            index = formattedCharacter.index + 1;
+        }
+        return state.formatted;
+    }
+    static formatDefaultCharacter(defaultStr, index, state) {
+        const character = defaultStr[index];
+        if (state.textStartCharacter !== undefined) {
+            return this.formatDefaultStringCharacter(defaultStr, index, state, character);
+        }
+        return this.formatDefaultNonStringCharacter(defaultStr, index, state, character);
+    }
+    static formatDefaultStringCharacter(defaultStr, index, state, character) {
+        if (character === state.textStartCharacter) {
+            return {
+                formatted: `${state.formatted}"`,
+                index,
+            };
+        }
+        if (character === '"') {
+            return {
+                ...state,
+                formatted: `${state.formatted}${escapedDoubleQuote}`,
+                index,
+            };
+        }
+        if (character !== backslash) {
+            return {
+                ...state,
+                formatted: `${state.formatted}${character}`,
+                index,
+            };
+        }
+        return this.formatEscapedDefaultCharacter(defaultStr, index, state);
+    }
+    static formatEscapedDefaultCharacter(defaultStr, index, state) {
+        const nextIndex = index + 1;
+        if (nextIndex >= defaultStr.length) {
+            return {
+                ...state,
+                formatted: `${state.formatted}${backslash}`,
+                index,
+            };
+        }
+        const nextCharacter = defaultStr[nextIndex];
+        if (['n', 't', 'r', 'b', 'f', backslash, '"'].includes(nextCharacter)) {
+            return {
+                ...state,
+                formatted: `${state.formatted}${backslash}${nextCharacter}`,
+                index: nextIndex,
+            };
+        }
+        if (!['v', '0'].includes(nextCharacter)) {
+            return {
+                ...state,
+                formatted: `${state.formatted}${nextCharacter}`,
+                index: nextIndex,
+            };
+        }
+        return {
+            ...state,
+            index: nextIndex,
+        };
+    }
+    static formatDefaultNonStringCharacter(defaultStr, index, state, character) {
+        if (this.isDefaultStringDelimiter(character)) {
+            return {
+                formatted: `${state.formatted}"`,
+                textStartCharacter: character,
+                index,
+            };
+        }
+        if (this.startsDefaultLineComment(defaultStr, index)) {
+            return this.skipDefaultLineComment(defaultStr, index, state);
+        }
+        return {
+            ...state,
+            formatted: `${state.formatted}${character}`,
+            index,
+        };
+    }
+    static isDefaultStringDelimiter(character) {
+        return character === '"' || character === "'" || character === '`';
+    }
+    static startsDefaultLineComment(defaultStr, index) {
+        return defaultStr[index] === '/' && defaultStr[index + 1] === '/';
+    }
+    static skipDefaultLineComment(defaultStr, index, state) {
+        let nextIndex = index + 2;
+        while (nextIndex < defaultStr.length && defaultStr[nextIndex] !== '\n') {
+            nextIndex += 1;
+        }
+        return {
+            ...state,
+            index: nextIndex,
+        };
     }
 }
 exports.TypeResolver = TypeResolver;