@trapi/metadata 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/resolver/module.js

@@ -1,1089 +1,1103 @@
-"use strict";
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeNodeResolver = void 0;
-const ts = __importStar(require("typescript"));
-const decorator_1 = require("../decorator");
-const utils_1 = require("../utils");
-const error_1 = require("./error");
-const localReferenceTypeCache = {};
-const inProgressTypes = {};
-class TypeNodeResolver {
-    constructor(typeNode, current, parentNode, context, referencer) {
-        this.attemptToResolveKindToPrimitive = (syntaxKind) => {
-            if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
-                return 'number';
-            }
-            if (syntaxKind === ts.SyntaxKind.StringKeyword) {
-                return 'string';
-            }
-            if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
-                return 'boolean';
-            }
-            if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
-                return 'void';
-            }
-            return undefined;
-        };
-        this.typeNode = typeNode;
-        this.current = current;
-        this.parentNode = parentNode;
-        this.context = context || {};
-        this.referencer = referencer;
-    }
-    static clearCache() {
-        Object.keys(localReferenceTypeCache).forEach((key) => {
-            delete localReferenceTypeCache[key];
-        });
-        Object.keys(inProgressTypes).forEach((key) => {
-            delete inProgressTypes[key];
-        });
-    }
-    resolve() {
-        const primitiveType = this.getPrimitiveType(this.typeNode, this.parentNode);
-        if (primitiveType) {
-            return primitiveType;
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.NullKeyword) {
-            return {
-                typeName: 'enum',
-                members: [null],
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return {
-                typeName: 'array',
-                elementType: new TypeNodeResolver(this.typeNode.elementType, this.current, this.parentNode, this.context).resolve(),
-            };
-        }
-        if (ts.isUnionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
-            return {
-                typeName: 'union',
-                members: types,
-            };
-        }
-        if (ts.isIntersectionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
-            return {
-                typeName: 'intersection',
-                members: types,
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.AnyKeyword ||
-            this.typeNode.kind === ts.SyntaxKind.UnknownKeyword ||
-            this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
-            return {
-                typeName: 'any',
-            };
-        }
-        if (ts.isLiteralTypeNode(this.typeNode)) {
-            return {
-                typeName: 'enum',
-                members: [TypeNodeResolver.getLiteralValue(this.typeNode)],
-            };
-        }
-        if (ts.isTypeLiteralNode(this.typeNode)) {
-            const properties = this.typeNode.members
-                .filter((member) => ts.isPropertySignature(member))
-                .reduce((res, propertySignature) => {
-                const type = new TypeNodeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve();
-                const property = {
-                    deprecated: (0, utils_1.hasJSDocTag)(propertySignature, utils_1.JSDocTagName.DEPRECATED),
-                    example: this.getNodeExample(propertySignature),
-                    default: (0, utils_1.getJSDocTagComment)(propertySignature, utils_1.JSDocTagName.DEFAULT),
-                    description: this.getNodeDescription(propertySignature),
-                    format: TypeNodeResolver.getNodeFormat(propertySignature),
-                    name: propertySignature.name.text,
-                    required: !propertySignature.questionToken,
-                    type,
-                    validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
-                };
-                return [property, ...res];
-            }, []);
-            const indexMember = this.typeNode.members.find((member) => ts.isIndexSignatureDeclaration(member));
-            let additionalType;
-            if (indexMember) {
-                const indexSignatureDeclaration = indexMember;
-                const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-                if (indexType.typeName !== 'string') {
-                    throw new error_1.ResolverError('Only string indexes are supported.', this.typeNode);
-                }
-                additionalType = new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
-            }
-            return {
-                additionalProperties: indexMember && additionalType,
-                typeName: 'nestedObjectLiteral',
-                properties,
-            };
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword || ts.isFunctionTypeNode(this.typeNode)) {
-            return { typeName: 'object' };
-        }
-        if (ts.isMappedTypeNode(this.typeNode) && this.referencer) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
-            const mappedTypeNode = this.typeNode;
-            const { typeChecker } = this.current;
-            const getDeclaration = (prop) => prop.declarations && prop.declarations[0];
-            const isIgnored = (prop) => {
-                const declaration = getDeclaration(prop);
-                return (prop.getJsDocTags().find((tag) => tag.name === 'ignore') !== undefined ||
-                    (declaration !== undefined &&
-                        !ts.isPropertyDeclaration(declaration) &&
-                        !ts.isPropertySignature(declaration) &&
-                        !ts.isParameter(declaration)));
-            };
-            const properties = type
-                .getProperties()
-                // Ignore methods, getter, setter and @ignored props
-                .filter((property) => isIgnored(property) === false)
-                // Transform to property
-                .map((property) => {
-                const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
-                const declaration = getDeclaration(property);
-                if (declaration && ts.isPropertySignature(declaration)) {
-                    return { ...this.propertyFromSignature(declaration, mappedTypeNode.questionToken), name: property.getName() };
-                }
-                if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) {
-                    return { ...this.propertyFromDeclaration(declaration, mappedTypeNode.questionToken), name: property.getName() };
-                }
-                // Resolve default value, required and typeNode
-                let required = false;
-                const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
-                if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.MinusToken) {
-                    required = true;
-                }
-                else if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.QuestionToken) {
-                    required = false;
-                }
-                // Push property
-                return {
-                    name: property.getName(),
-                    required,
-                    deprecated: false,
-                    type: new TypeNodeResolver(typeNode, this.current, this.typeNode, this.context, this.referencer).resolve(),
-                    validators: {},
-                };
-            });
-            return {
-                typeName: 'nestedObjectLiteral',
-                properties,
-            };
-        }
-        if (ts.isConditionalTypeNode(this.typeNode) && this.referencer && ts.isTypeReferenceNode(this.referencer)) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
-            if (type.aliasSymbol) {
-                let declaration = type.aliasSymbol.declarations[0];
-                if (declaration.name) {
-                    declaration = this.getModelTypeDeclaration(declaration.name);
-                }
-                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
-                return this.handleCachingAndCircularReferences(name, () => {
-                    if (ts.isTypeAliasDeclaration(declaration)) {
-                        // Note: I don't understand why typescript lose type for `this.referencer` (from above with isTypeReferenceNode())
-                        return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
-                    }
-                    if (ts.isEnumDeclaration(declaration)) {
-                        return this.getEnumerateType(declaration.name);
-                    }
-                    throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
-                });
-            }
-            if (type.isClassOrInterface()) {
-                let declaration = type.symbol.declarations[0];
-                if (declaration.name) {
-                    declaration = this.getModelTypeDeclaration(declaration.name);
-                }
-                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
-                return this.handleCachingAndCircularReferences(name, () => this.getModelReference(declaration, this.current.typeChecker.typeToString(type)));
-            }
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch {
-                throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
-            }
-        }
-        if (ts.isTypeOperatorNode(this.typeNode) && this.typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch (err) {
-                const indexedTypeName = this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.type));
-                throw new error_1.ResolverError(`Could not determine the keys on ${indexedTypeName}`, this.typeNode);
-            }
-        }
-        if (ts.isTypeOperatorNode(this.typeNode) && this.typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) {
-            return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
-        }
-        if (ts.isIndexedAccessTypeNode(this.typeNode) &&
-            (this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword ||
-                this.typeNode.indexType.kind === ts.SyntaxKind.StringKeyword)) {
-            const numberIndexType = this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword;
-            const objectType = this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType);
-            const type = numberIndexType ? objectType.getNumberIndexType() : objectType.getStringIndexType();
-            if (type === undefined) {
-                throw new error_1.ResolverError(`Could not determine ${numberIndexType ? 'number' : 'string'} index on ${this.current.typeChecker.typeToString(objectType)}`, this.typeNode);
-            }
-            return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
-        }
-        if (ts.isIndexedAccessTypeNode(this.typeNode) &&
-            ts.isLiteralTypeNode(this.typeNode.indexType) &&
-            (ts.isStringLiteral(this.typeNode.indexType.literal) || ts.isNumericLiteral(this.typeNode.indexType.literal))) {
-            const hasType = (node) => node !== undefined &&
-                Object.prototype.hasOwnProperty.call(node, 'type');
-            const symbol = this.current.typeChecker.getPropertyOfType(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType), this.typeNode.indexType.literal.text);
-            if (symbol === undefined) {
-                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType))}`, this.typeNode);
-            }
-            if (hasType(symbol.valueDeclaration) && symbol.valueDeclaration.type) {
-                return new TypeNodeResolver(symbol.valueDeclaration.type, this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            const declaration = this.current.typeChecker.getTypeOfSymbolAtLocation(symbol, this.typeNode.objectType);
-            try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
-            }
-            catch {
-                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined)))}`, this.typeNode);
-            }
-        }
-        if (this.typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
-            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
-            if (type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral())) {
-                return {
-                    typeName: 'enum',
-                    members: type.types.map((stringLiteralType) => stringLiteralType.value),
-                };
-            }
-            throw new error_1.ResolverError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode);
-        }
-        if (ts.isParenthesizedTypeNode(this.typeNode)) {
-            return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
-        }
-        if (this.typeNode.kind !== ts.SyntaxKind.TypeReference) {
-            throw new error_1.ResolverError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode);
-        }
-        const typeReference = this.typeNode;
-        if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
-            // Special Utility Type
-            if (typeReference.typeName.text === 'Record') {
-                return {
-                    additionalProperties: new TypeNodeResolver(typeReference.typeArguments[1], this.current, this.parentNode, this.context).resolve(),
-                    typeName: 'nestedObjectLiteral',
-                    properties: [],
-                };
-            }
-            const specialReference = TypeNodeResolver.resolveSpecialReference(typeReference.typeName);
-            if (typeof specialReference !== 'undefined') {
-                return specialReference;
-            }
-            if (typeReference.typeName.text === 'Date') {
-                return this.getDateType(this.parentNode);
-            }
-            if (typeReference.typeName.text === 'Buffer' ||
-                typeReference.typeName.text === 'Readable') {
-                return { typeName: 'buffer' };
-            }
-            if (typeReference.typeName.text === 'Array' &&
-                typeReference.typeArguments &&
-                typeReference.typeArguments.length >= 1) {
-                return {
-                    typeName: 'array',
-                    elementType: new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve(),
-                };
-            }
-            if (typeReference.typeName.text === 'Promise' &&
-                typeReference.typeArguments &&
-                typeReference.typeArguments.length === 1) {
-                return new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve();
-            }
-            if (typeReference.typeName.text === 'String') {
-                return { typeName: 'string' };
-            }
-            if (this.context[typeReference.typeName.text]) {
-                return new TypeNodeResolver(this.context[typeReference.typeName.text], this.current, this.parentNode, this.context).resolve();
-            }
-        }
-        const referenceType = this.getReferenceType(typeReference);
-        this.current.addReferenceType(referenceType);
-        return referenceType;
-    }
-    // ------------------------------------------------------------------------
-    // Utility Type(s)
-    // ------------------------------------------------------------------------
-    static isSupportedUtilityType(typeName) {
-        if (typeof typeName === 'undefined') {
-            return false;
-        }
-        return ['NonNullable', 'Pick', 'Omit', 'Partial', 'Readonly', 'Record', 'Required'].indexOf(typeof typeName !== 'string' ? typeName.text : typeName) !== -1;
-    }
-    static getUtilityTypeOptions(typeArguments) {
-        const utilityOptions = {
-            keys: [],
-        };
-        if (typeArguments.length >= 2) {
-            if (ts.isUnionTypeNode(typeArguments[1])) {
-                const args = typeArguments[1].types;
-                for (let i = 0; i < args.length; i++) {
-                    if (ts.isLiteralTypeNode(args[i])) {
-                        utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(args[i]));
-                    }
-                }
-            }
-            if (ts.isLiteralTypeNode(typeArguments[1])) {
-                utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(typeArguments[1]));
-            }
-        }
-        return utilityOptions;
-    }
-    filterUtilityProperties(properties, utilityType, utilityOptions) {
-        if (typeof utilityType === 'undefined' || typeof utilityOptions === 'undefined') {
-            return properties;
-        }
-        return properties
-            .filter((property) => {
-            const name = typeof property.name !== 'string' ? property.name.text : property.name;
-            switch (utilityType) {
-                case 'Pick':
-                    return utilityOptions.keys.indexOf(name) !== -1;
-                case 'Omit':
-                    return utilityOptions.keys.indexOf(name) === -1;
-            }
-            return true;
-        })
-            .map((property) => {
-            if ((0, utils_1.hasOwnProperty)(property, 'required')) {
-                switch (utilityType) {
-                    case 'Partial':
-                        property.required = false;
-                        break;
-                    case 'Required':
-                    case 'NonNullable':
-                        property.required = true;
-                        break;
-                }
-            }
-            return property;
-        });
-    }
-    static resolveSpecialReference(node) {
-        switch (node.text) {
-            case 'Buffer':
-            case 'DownloadBinaryData':
-            case 'DownloadResource':
-                return { typeName: 'buffer' };
-            default:
-                return undefined;
-        }
-    }
-    static getLiteralValue(typeNode) {
-        let value;
-        switch (typeNode.literal.kind) {
-            case ts.SyntaxKind.TrueKeyword:
-                value = true;
-                break;
-            case ts.SyntaxKind.FalseKeyword:
-                value = false;
-                break;
-            case ts.SyntaxKind.StringLiteral:
-                value = typeNode.literal.text;
-                break;
-            case ts.SyntaxKind.NumericLiteral:
-                value = parseFloat(typeNode.literal.text);
-                break;
-            case ts.SyntaxKind.NullKeyword:
-                value = null;
-                break;
-            default:
-                if (Object.prototype.hasOwnProperty.call(typeNode.literal, 'text')) {
-                    value = typeNode.literal.text;
-                }
-                else {
-                    throw new error_1.ResolverError(`Couldn't resolve literal node: ${typeNode.literal.getText()}`);
-                }
-        }
-        return value;
-    }
-    getPrimitiveType(typeNode, parentNode) {
-        if (!typeNode) {
-            return {
-                typeName: 'void',
-            };
-        }
-        const resolvedType = this.attemptToResolveKindToPrimitive(typeNode.kind);
-        if (typeof resolvedType === 'undefined') {
-            return undefined;
-        }
-        if (resolvedType === 'number') {
-            if (!parentNode) {
-                return { typeName: 'double' };
-            }
-            const lookupTags = [
-                'isInt',
-                'isLong',
-                'isFloat',
-                'isDouble',
-            ];
-            const tags = (0, utils_1.getJSDocTagNames)(parentNode)
-                .filter((name) => lookupTags.some((m) => m.toLowerCase() === name.toLowerCase()))
-                .map((name) => name.toLowerCase());
-            const decoratorIds = [
-                decorator_1.DecoratorID.IS_INT,
-                decorator_1.DecoratorID.IS_LONG,
-                decorator_1.DecoratorID.IS_FLOAT,
-                decorator_1.DecoratorID.IS_DOUBLE,
-            ];
-            let decoratorID;
-            for (let i = 0; i < decoratorIds.length; i++) {
-                const decorator = this.current.decoratorResolver.match(decoratorIds[i], parentNode);
-                if (decorator) {
-                    decoratorID = decoratorIds[i];
-                    break;
-                }
-            }
-            if (!decoratorID && tags.length === 0) {
-                return { typeName: 'double' };
-            }
-            switch (decoratorID || tags[0]) {
-                case decorator_1.DecoratorID.IS_INT:
-                case 'isint':
-                    return { typeName: 'integer' };
-                case decorator_1.DecoratorID.IS_LONG:
-                case 'islong':
-                    return { typeName: 'long' };
-                case decorator_1.DecoratorID.IS_FLOAT:
-                case 'isfloat':
-                    return { typeName: 'float' };
-                case decorator_1.DecoratorID.IS_DOUBLE:
-                case 'isdouble':
-                    return { typeName: 'double' };
-                default:
-                    return { typeName: 'double' };
-            }
-        }
-        else if (resolvedType === 'string') {
-            return {
-                typeName: 'string',
-            };
-        }
-        else if (resolvedType === 'boolean') {
-            return {
-                typeName: 'boolean',
-            };
-        }
-        else if (resolvedType === 'void') {
-            return {
-                typeName: 'void',
-            };
-        }
-        else {
-            // todo: should not occur
-            return {
-                typeName: resolvedType,
-            };
-        }
-    }
-    getDateType(parentNode) {
-        if (!parentNode) {
-            return { typeName: 'datetime' };
-        }
-        const tags = (0, utils_1.getJSDocTagNames)(parentNode).filter((name) => ['isDate', 'isDateTime'].some((m) => m === name));
-        if (tags.length === 0) {
-            return { typeName: 'datetime' };
-        }
-        switch (tags[0]) {
-            case 'isDate':
-                return { typeName: 'date' };
-            case 'isDateTime':
-                return { typeName: 'datetime' };
-            default:
-                return { typeName: 'datetime' };
-        }
-    }
-    static getDesignatedModels(nodes, typeName) {
-        return nodes;
-    }
-    getEnumerateType(typeName) {
-        const enumName = typeName.text;
-        let enumNodes = this.current.nodes.filter((node) => node.kind === ts.SyntaxKind.EnumDeclaration && node.name.text === enumName);
-        if (!enumNodes.length) {
-            return undefined;
-        }
-        enumNodes = TypeNodeResolver.getDesignatedModels(enumNodes, enumName);
-        if (enumNodes.length > 1) {
-            throw new error_1.ResolverError(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
-        }
-        const enumDeclaration = enumNodes[0];
-        const isNotUndefined = (item) => item !== undefined;
-        const enums = enumDeclaration.members.map(this.current.typeChecker.getConstantValue.bind(this.current.typeChecker)).filter(isNotUndefined);
-        const enumNames = enumDeclaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
-        return {
-            typeName: 'refEnum',
-            description: this.getNodeDescription(enumDeclaration),
-            members: enums,
-            memberNames: enumNames,
-            refName: enumName,
-            deprecated: (0, utils_1.hasJSDocTag)(enumDeclaration, utils_1.JSDocTagName.DEPRECATED),
-        };
-    }
-    getReferenceType(node) {
-        let type;
-        if (ts.isTypeReferenceNode(node)) {
-            type = node.typeName;
-        }
-        else if (ts.isExpressionWithTypeArguments(node)) {
-            type = node.expression;
-        }
-        else {
-            throw new error_1.ResolverError('Can\'t resolve Reference type.');
-        }
-        // Can't invoke getText on Synthetic Nodes
-        let resolvableName = node.pos !== -1 ? node.getText() : type.text;
-        if (node.pos === -1 && 'typeArguments' in node && Array.isArray(node.typeArguments)) {
-            // Add typeArguments for Synthetic nodes (e.g. Record<> in TestClassModel.indexedResponse)
-            const argumentsString = node.typeArguments
-                .map((arg) => {
-                if (ts.isLiteralTypeNode(arg)) {
-                    return `'${String(TypeNodeResolver.getLiteralValue(arg))}'`;
-                }
-                const resolvedType = this.attemptToResolveKindToPrimitive(arg.kind);
-                if (typeof resolvedType === 'undefined') {
-                    return 'any';
-                }
-                return resolvedType;
-            });
-            resolvableName += `<${argumentsString.join(', ')}>`;
-        }
-        const name = this.contextualizedName(resolvableName);
-        // Handle Utility Types
-        const identifierName = type.text;
-        const utilityTypeSupported = TypeNodeResolver.isSupportedUtilityType(identifierName);
-        const utilityType = utilityTypeSupported ? identifierName : undefined;
-        let utilityOptions = {
-            keys: [],
-        };
-        if (utilityTypeSupported) {
-            const { typeArguments } = type.parent;
-            if (ts.isTypeReferenceNode(typeArguments[0])) {
-                type = typeArguments[0].typeName;
-            }
-            else if (ts.isExpressionWithTypeArguments(typeArguments[0])) {
-                type = typeArguments[0].expression;
-            }
-            else {
-                throw new error_1.ResolverError('Can\'t resolve Reference type.');
-            }
-            utilityOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
-        }
-        else {
-            this.typeArgumentsToContext(node, type, this.context);
-        }
-        try {
-            const existingType = localReferenceTypeCache[name];
-            if (existingType) {
-                return existingType;
-            }
-            const refEnumType = this.getEnumerateType(type);
-            if (refEnumType) {
-                localReferenceTypeCache[name] = refEnumType;
-                return refEnumType;
-            }
-            if (inProgressTypes[name]) {
-                return this.createCircularDependencyResolver(name);
-            }
-            inProgressTypes[name] = true;
-            const declaration = this.getModelTypeDeclaration(type);
-            let referenceType;
-            if (ts.isTypeAliasDeclaration(declaration)) {
-                referenceType = this.getTypeAliasReference(declaration, name, node);
-            }
-            else if (ts.isEnumMember(declaration)) {
-                referenceType = {
-                    typeName: 'refEnum',
-                    refName: TypeNodeResolver.getRefTypeName(name, utilityType),
-                    members: [this.current.typeChecker.getConstantValue(declaration)],
-                    memberNames: [declaration.name.getText()],
-                    deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
-                };
-            }
-            else {
-                // todo: dont cast handle property-signature
-                referenceType = this.getModelReference(declaration, name, utilityType, utilityOptions);
-            }
-            localReferenceTypeCache[name] = referenceType;
-            return referenceType;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(`There was a problem resolving type of '${name}'.`);
-            throw err;
-        }
-    }
-    getTypeAliasReference(declaration, name, referencer) {
-        const refName = TypeNodeResolver.getRefTypeName(name);
-        let type;
-        if (declaration.type.kind === ts.SyntaxKind.TypeReference) {
-            const referenceType = this.getReferenceType(declaration.type);
-            if (referenceType.refName === refName) {
-                return referenceType;
-            }
-        }
-        if (typeof type === 'undefined') {
-            type = new TypeNodeResolver(declaration.type, this.current, declaration, this.context, this.referencer || referencer).resolve();
-        }
-        const example = this.getNodeExample(declaration);
-        return {
-            typeName: 'refAlias',
-            default: (0, utils_1.getJSDocTagComment)(declaration, utils_1.JSDocTagName.DEFAULT),
-            description: this.getNodeDescription(declaration),
-            refName,
-            format: TypeNodeResolver.getNodeFormat(declaration),
-            type,
-            validators: (0, utils_1.getDeclarationValidators)(declaration) || {},
-            deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
-            ...(example && { example }),
-        };
-    }
-    getModelReference(modelType, name, utilityType, utilityOptions) {
-        const example = this.getNodeExample(modelType);
-        const description = this.getNodeDescription(modelType);
-        const deprecated = (0, utils_1.hasJSDocTag)(modelType, utils_1.JSDocTagName.DEPRECATED) ||
-            !!this.current.decoratorResolver.match(decorator_1.DecoratorID.DEPRECATED, modelType);
-        // Handle toJSON methods
-        if (!modelType.name) {
-            throw new error_1.ResolverError('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;
-            if (!nodeType) {
-                const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
-                const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
-                nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
-            }
-            return {
-                refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`,
-                typeName: 'refAlias',
-                description,
-                type: new TypeNodeResolver(nodeType, this.current).resolve(),
-                deprecated,
-                validators: {},
-                ...(example && { example }),
-            };
-        }
-        const properties = this.getModelProperties(modelType, undefined, utilityType, utilityOptions);
-        const additionalProperties = this.getModelAdditionalProperties(modelType);
-        const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
-        const referenceType = {
-            additionalProperties,
-            typeName: 'refObject',
-            description,
-            properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions),
-            refName: TypeNodeResolver.getRefTypeName(name, utilityType),
-            deprecated,
-            ...(example && { example }),
-        };
-        referenceType.properties = referenceType.properties.concat(properties);
-        return referenceType;
-    }
-    static getRefTypeName(name, utilityType) {
-        return encodeURIComponent(name
-            .replace(/<|>/g, '_')
-            .replace(/\s+/g, '')
-            .replace(/,/g, '.')
-            .replace(/'([^']*)'/g, '$1')
-            .replace(/"([^"]*)"/g, '$1')
-            .replace(/&/g, typeof utilityType !== 'undefined' ? '--' : '-and-')
-            .replace(/\|/g, typeof utilityType !== 'undefined' ? '--' : '-or-')
-            .replace(/\[\]/g, '-array')
-            .replace(/{|}/g, '_') // SuccessResponse_{indexesCreated-number}_ -> SuccessResponse__indexesCreated-number__
-            .replace(/([a-z]+):([a-z]+)/gi, '$1-$2') // SuccessResponse_indexesCreated:number_ -> SuccessResponse_indexesCreated-number_
-            .replace(/;/g, '--')
-            .replace(/([a-z]+)\[([a-z]+)\]/gi, '$1-at-$2') // Partial_SerializedDatasourceWithVersion[format]_ -> Partial_SerializedDatasourceWithVersion~format~_,
-            .replace(/_/g, '')
-            .replace(/-/g, ''));
-    }
-    contextualizedName(name) {
-        return Object.entries(this.context).reduce((acc, [key, entry]) => acc
-            .replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `<$1${entry.getText()}$3>`)
-            .replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, 'g'), `<$1${entry.getText()}$3,`)
-            .replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `,$1${entry.getText()}$3>`)
-            .replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, 'g'), `<$1${entry.getText()}$3<`), name);
-    }
-    handleCachingAndCircularReferences(name, declarationResolver) {
-        try {
-            const existingType = localReferenceTypeCache[name];
-            if (existingType) {
-                return existingType;
-            }
-            if (inProgressTypes[name]) {
-                return this.createCircularDependencyResolver(name);
-            }
-            inProgressTypes[name] = true;
-            const reference = declarationResolver();
-            localReferenceTypeCache[name] = reference;
-            this.current.addReferenceType(reference);
-            return reference;
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.error(`There was a problem resolving type of '${name}'.`);
-            throw err;
-        }
-    }
-    createCircularDependencyResolver(refName) {
-        const referenceType = {
-            typeName: 'refObject',
-            refName,
-        };
-        this.current.registerDependencyResolver((referenceTypes) => {
-            const realReferenceType = referenceTypes[refName];
-            if (!realReferenceType) {
-                return;
-            }
-            referenceType.description = realReferenceType.description;
-            if (realReferenceType.typeName === 'refObject' && referenceType.typeName === 'refObject') {
-                referenceType.properties = realReferenceType.properties;
-            }
-            referenceType.typeName = realReferenceType.typeName;
-            referenceType.refName = realReferenceType.refName;
-        });
-        return referenceType;
-    }
-    static nodeIsUsable(node) {
-        switch (node.kind) {
-            case ts.SyntaxKind.InterfaceDeclaration:
-            case ts.SyntaxKind.ClassDeclaration:
-            case ts.SyntaxKind.TypeAliasDeclaration:
-            case ts.SyntaxKind.EnumDeclaration:
-            case ts.SyntaxKind.EnumMember:
-                return true;
-            default:
-                return false;
-        }
-    }
-    getModelTypeDeclaration(type) {
-        let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
-        const symbol = this.getSymbolAtLocation(type);
-        const declarations = symbol.getDeclarations();
-        if (declarations.length === 0) {
-            throw new error_1.ResolverError(`No models found for referenced type ${typeName}.`);
-        }
-        if (symbol.escapedName !== typeName && symbol.escapedName !== 'default') {
-            typeName = symbol.escapedName;
-        }
-        let modelTypes = declarations.filter((node) => {
-            if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) {
-                return false;
-            }
-            const modelTypeDeclaration = node;
-            return modelTypeDeclaration.name?.text === typeName;
-        });
-        if (!modelTypes.length) {
-            throw new error_1.ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
-        }
-        if (modelTypes.length > 1) {
-            // remove types that are from typescript e.g. 'Account'
-            modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile()
-                .fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules/typescript') <= -1);
-            modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
-        }
-        if (modelTypes.length > 1) {
-            const conflicts = modelTypes.map((modelType) => modelType.getSourceFile().fileName).join('"; "');
-            throw new error_1.ResolverError(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
-        }
-        return modelTypes[0];
-    }
-    hasFlag(type, flag) {
-        return (type.flags & flag) === flag;
-    }
-    getSymbolAtLocation(type) {
-        const symbol = this.current.typeChecker.getSymbolAtLocation(type) || type.symbol;
-        // resolve alias if it is an alias, otherwise take symbol directly
-        return (symbol &&
-            this.hasFlag(symbol, ts.SymbolFlags.Alias) &&
-            this.current.typeChecker.getAliasedSymbol(symbol)) || symbol;
-    }
-    getModelProperties(node, overrideToken, utilityType, utilityOptions) {
-        const isIgnored = (e) => (0, utils_1.hasJSDocTag)(e, utils_1.JSDocTagName.IGNORE);
-        // Interface model
-        if (ts.isInterfaceDeclaration(node)) {
-            return node.members.filter((member) => !isIgnored(member) &&
-                ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
-        }
-        // Class model
-        let properties = node.members
-            .filter((member) => !isIgnored(member) &&
-            member.kind === ts.SyntaxKind.PropertyDeclaration &&
-            !this.hasStaticModifier(member) &&
-            this.hasPublicModifier(member));
-        const classConstructor = node.members.find((member) => ts.isConstructorDeclaration(member));
-        if (classConstructor && classConstructor.parameters) {
-            const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
-            properties.push(...constructorProperties);
-        }
-        properties = this.filterUtilityProperties(properties, utilityType, utilityOptions);
-        return properties.map((property) => this.propertyFromDeclaration(property, overrideToken, utilityType));
-    }
-    propertyFromSignature(propertySignature, overrideToken) {
-        const identifier = propertySignature.name;
-        if (!propertySignature.type) {
-            throw new error_1.ResolverError('No valid type found for property declaration.');
-        }
-        let required = !propertySignature.questionToken;
-        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
-            required = true;
-        }
-        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
-            required = false;
-        }
-        const property = {
-            deprecated: (0, utils_1.hasJSDocTag)(propertySignature, utils_1.JSDocTagName.DEPRECATED),
-            default: (0, utils_1.getJSDocTagComment)(propertySignature, utils_1.JSDocTagName.DEFAULT),
-            description: this.getNodeDescription(propertySignature),
-            example: this.getNodeExample(propertySignature),
-            format: TypeNodeResolver.getNodeFormat(propertySignature),
-            name: identifier.text,
-            required,
-            type: new TypeNodeResolver(propertySignature.type, this.current, propertySignature.type.parent, this.context, propertySignature.type).resolve(),
-            validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
-        };
-        return property;
-    }
-    propertyFromDeclaration(propertyDeclaration, overrideToken, utilityType) {
-        const identifier = propertyDeclaration.name;
-        let typeNode = propertyDeclaration.type;
-        if (!typeNode) {
-            const tsType = this.current.typeChecker.getTypeAtLocation(propertyDeclaration);
-            typeNode = this.current.typeChecker.typeToTypeNode(tsType, undefined, ts.NodeBuilderFlags.NoTruncation);
-        }
-        if (!typeNode) {
-            throw new error_1.ResolverError('No valid type found for property declaration.');
-        }
-        const type = new TypeNodeResolver(typeNode, this.current, propertyDeclaration, this.context, typeNode).resolve();
-        let required = !propertyDeclaration.questionToken && !propertyDeclaration.initializer;
-        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
-            required = true;
-        }
-        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
-            required = false;
-        }
-        if (typeof utilityType !== 'undefined') {
-            if (utilityType === 'Partial') {
-                required = false;
-            }
-            if (utilityType === 'Required') {
-                required = true;
-            }
-        }
-        const property = {
-            deprecated: (0, utils_1.hasJSDocTag)(propertyDeclaration, utils_1.JSDocTagName.DEPRECATED),
-            default: (0, utils_1.getInitializerValue)(propertyDeclaration.initializer, this.current.typeChecker),
-            description: this.getNodeDescription(propertyDeclaration),
-            example: this.getNodeExample(propertyDeclaration),
-            format: TypeNodeResolver.getNodeFormat(propertyDeclaration),
-            name: identifier.text,
-            required,
-            type,
-            validators: (0, utils_1.getDeclarationValidators)(propertyDeclaration) || {},
-        };
-        return property;
-    }
-    getModelAdditionalProperties(node) {
-        if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
-            const indexMember = node.members.find((member) => member.kind === ts.SyntaxKind.IndexSignature);
-            if (!indexMember) {
-                return undefined;
-            }
-            const indexSignatureDeclaration = indexMember;
-            const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-            if (indexType.typeName !== 'string') {
-                throw new error_1.ResolverError('Only string indexers are supported.', this.typeNode);
-            }
-            return new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
-        }
-        return undefined;
-    }
-    typeArgumentsToContext(type, targetEntity, context) {
-        // this.context = {};
-        const declaration = this.getModelTypeDeclaration(targetEntity);
-        if (typeof declaration === 'undefined' || !('typeParameters' in declaration)) {
-            return context;
-        }
-        const { typeParameters } = declaration;
-        if (typeParameters) {
-            for (let index = 0; index < typeParameters.length; index++) {
-                const typeParameter = typeParameters[index];
-                const typeArg = type.typeArguments && type.typeArguments[index];
-                let resolvedType;
-                // Argument may be a forward reference from context
-                if (typeArg && ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && context[typeArg.typeName.text]) {
-                    resolvedType = context[typeArg.typeName.text];
-                }
-                else if (typeArg) {
-                    resolvedType = typeArg;
-                }
-                else if (typeParameter.default) {
-                    resolvedType = typeParameter.default;
-                }
-                else {
-                    throw new error_1.ResolverError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
-                }
-                this.context = {
-                    ...this.context,
-                    [typeParameter.name.text]: resolvedType,
-                };
-            }
-        }
-        return context;
-    }
-    getModelInheritedProperties(modelTypeDeclaration) {
-        let properties = [];
-        const { heritageClauses } = modelTypeDeclaration;
-        if (!heritageClauses) {
-            return properties;
-        }
-        heritageClauses.forEach((clause) => {
-            if (!clause.types) {
-                return;
-            }
-            clause.types.forEach((t) => {
-                const baseEntityName = t.expression;
-                // create subContext
-                const resetCtx = this.typeArgumentsToContext(t, baseEntityName, this.context);
-                const referenceType = this.getReferenceType(t);
-                if (referenceType) {
-                    if (referenceType.typeName === 'refEnum') {
-                        // since it doesn't have properties to iterate over, then we don't do anything with it
-                    }
-                    else if (referenceType.typeName === 'refAlias') {
-                        let type = referenceType;
-                        while (type.typeName === 'refAlias') {
-                            type = type.type;
-                        }
-                        if (type.typeName === 'refObject') {
-                            properties = [...properties, ...type.properties];
-                        }
-                        else if (type.typeName === 'nestedObjectLiteral') {
-                            properties = [...properties, ...type.properties];
-                        }
-                    }
-                    else if (referenceType.typeName === 'refObject') {
-                        referenceType.properties.forEach((property) => properties.push(property));
-                    }
-                    else {
-                        // todo: should never assert
-                    }
-                }
-                // reset subContext
-                this.context = resetCtx;
-            });
-        });
-        return properties;
-    }
-    hasPublicModifier(node) {
-        if (!ts.canHaveModifiers(node)) {
-            return true;
-        }
-        const modifiers = ts.getModifiers(node);
-        if (!modifiers) {
-            return true;
-        }
-        return modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword);
-    }
-    hasStaticModifier(node) {
-        if (!ts.canHaveModifiers(node)) {
-            return false;
-        }
-        const modifiers = ts.getModifiers(node);
-        return modifiers && modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
-    }
-    isAccessibleParameter(node) {
-        // No modifiers
-        if (!ts.canHaveModifiers(node)) {
-            return false;
-        }
-        const modifiers = ts.getModifiers(node);
-        if (!modifiers) {
-            return false;
-        }
-        // public || public readonly
-        if (modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
-            return true;
-        }
-        // readonly, not private readonly, not public readonly
-        const isReadonly = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
-        const isProtectedOrPrivate = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ProtectedKeyword ||
-            modifier.kind === ts.SyntaxKind.PrivateKeyword);
-        return isReadonly && !isProtectedOrPrivate;
-    }
-    getNodeDescription(node) {
-        const symbol = this.current.typeChecker.getSymbolAtLocation(node.name);
-        if (!symbol) {
-            return undefined;
-        }
-        /**
-         * TODO: Workaround for what seems like a bug in the compiler
-         * Warrants more investigation and possibly a PR against typescript
-         */
-        if (node.kind === ts.SyntaxKind.Parameter) {
-            // TypeScript won't parse jsdoc if the flag is 4, i.e. 'Property'
-            symbol.flags = 0;
-        }
-        const comments = symbol.getDocumentationComment(this.current.typeChecker);
-        if (comments.length) {
-            return ts.displayPartsToString(comments);
-        }
-        return undefined;
-    }
-    static getNodeFormat(node) {
-        return (0, utils_1.getJSDocTagComment)(node, utils_1.JSDocTagName.FORMAT);
-    }
-    getNodeExample(node) {
-        const example = (0, utils_1.getJSDocTagComment)(node, utils_1.JSDocTagName.EXAMPLE);
-        if (example) {
-            try {
-                return JSON.parse(example);
-            }
-            catch {
-                // do nothing
-            }
-        }
-        return undefined;
-    }
-}
-exports.TypeNodeResolver = TypeNodeResolver;
+"use strict";
+/*
+ * Copyright (c) 2021.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeNodeResolver = void 0;
+const ts = __importStar(require("typescript"));
+const decorator_1 = require("../decorator");
+const constants_1 = require("./constants");
+const utils_1 = require("../utils");
+const error_1 = require("./error");
+const extension_1 = require("./extension");
+const type_1 = require("./type");
+const localReferenceTypeCache = {};
+const inProgressTypes = {};
+class TypeNodeResolver {
+    constructor(typeNode, current, parentNode, context, referencer) {
+        this.attemptToResolveKindToPrimitive = (syntaxKind) => {
+            if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
+                return 'number';
+            }
+            if (syntaxKind === ts.SyntaxKind.StringKeyword) {
+                return 'string';
+            }
+            if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
+                return 'boolean';
+            }
+            if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
+                return 'void';
+            }
+            return undefined;
+        };
+        this.typeNode = typeNode;
+        this.current = current;
+        this.parentNode = parentNode;
+        this.context = context || {};
+        this.referencer = referencer;
+    }
+    static clearCache() {
+        Object.keys(localReferenceTypeCache).forEach((key) => {
+            delete localReferenceTypeCache[key];
+        });
+        Object.keys(inProgressTypes).forEach((key) => {
+            delete inProgressTypes[key];
+        });
+    }
+    resolve() {
+        const primitiveType = this.getPrimitiveType(this.typeNode, this.parentNode);
+        if (primitiveType) {
+            return primitiveType;
+        }
+        if (this.typeNode.kind === ts.SyntaxKind.NullKeyword) {
+            return {
+                typeName: constants_1.TypeName.ENUM,
+                members: [null],
+            };
+        }
+        if (this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+            return {
+                typeName: constants_1.TypeName.UNDEFINED,
+            };
+        }
+        if (ts.isArrayTypeNode(this.typeNode)) {
+            return {
+                typeName: constants_1.TypeName.ARRAY,
+                elementType: new TypeNodeResolver(this.typeNode.elementType, this.current, this.parentNode, this.context).resolve(),
+            };
+        }
+        if (ts.isUnionTypeNode(this.typeNode)) {
+            const members = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
+            return {
+                typeName: constants_1.TypeName.UNION,
+                members,
+            };
+        }
+        if (ts.isIntersectionTypeNode(this.typeNode)) {
+            const members = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
+            return {
+                typeName: constants_1.TypeName.INTERSECTION,
+                members,
+            };
+        }
+        if (this.typeNode.kind === ts.SyntaxKind.AnyKeyword ||
+            this.typeNode.kind === ts.SyntaxKind.UnknownKeyword) {
+            return {
+                typeName: constants_1.TypeName.ANY,
+            };
+        }
+        if (ts.isLiteralTypeNode(this.typeNode)) {
+            return {
+                typeName: constants_1.TypeName.ENUM,
+                members: [TypeNodeResolver.getLiteralValue(this.typeNode)],
+            };
+        }
+        if (ts.isTypeLiteralNode(this.typeNode)) {
+            const properties = this.typeNode.members
+                .filter((member) => ts.isPropertySignature(member))
+                .reduce((res, propertySignature) => {
+                const type = new TypeNodeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve();
+                const property = {
+                    deprecated: (0, utils_1.hasJSDocTag)(propertySignature, utils_1.JSDocTagName.DEPRECATED),
+                    example: this.getNodeExample(propertySignature),
+                    extensions: this.getNodeExtensions(propertySignature),
+                    default: (0, utils_1.getJSDocTagComment)(propertySignature, utils_1.JSDocTagName.DEFAULT),
+                    description: this.getNodeDescription(propertySignature),
+                    format: TypeNodeResolver.getNodeFormat(propertySignature),
+                    name: propertySignature.name.text,
+                    required: !propertySignature.questionToken,
+                    type,
+                    validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
+                };
+                return [property, ...res];
+            }, []);
+            const indexMember = this.typeNode.members.find((member) => ts.isIndexSignatureDeclaration(member));
+            let additionalType;
+            if (indexMember) {
+                const indexSignatureDeclaration = indexMember;
+                const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
+                if (!(0, type_1.isStringType)(indexType)) {
+                    throw new error_1.ResolverError('Only string indexes are supported.', this.typeNode);
+                }
+                additionalType = new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
+            }
+            return {
+                additionalProperties: indexMember && additionalType,
+                typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
+                properties,
+            };
+        }
+        if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword ||
+            ts.isFunctionTypeNode(this.typeNode)) {
+            return { typeName: constants_1.TypeName.OBJECT };
+        }
+        if (ts.isMappedTypeNode(this.typeNode) && this.referencer) {
+            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
+            const mappedTypeNode = this.typeNode;
+            const { typeChecker } = this.current;
+            const getDeclaration = (prop) => prop.declarations && prop.declarations[0];
+            const isIgnored = (prop) => {
+                const declaration = getDeclaration(prop);
+                const tagNames = prop.getJsDocTags();
+                const tagNameIndex = tagNames.findIndex((tag) => tag.name === utils_1.JSDocTagName.IGNORE);
+                if (tagNameIndex >= 0) {
+                    return true;
+                }
+                return (!!declaration &&
+                    !ts.isPropertyDeclaration(declaration) &&
+                    !ts.isPropertySignature(declaration) &&
+                    !ts.isParameter(declaration));
+            };
+            const properties = type
+                .getProperties()
+                // Ignore methods, getter, setter and @ignored props
+                .filter((property) => isIgnored(property) === false)
+                // Transform to property
+                .map((property) => {
+                const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
+                const declaration = getDeclaration(property);
+                if (declaration && ts.isPropertySignature(declaration)) {
+                    return { ...this.propertyFromSignature(declaration, mappedTypeNode.questionToken), name: property.getName() };
+                }
+                if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) {
+                    return { ...this.propertyFromDeclaration(declaration, mappedTypeNode.questionToken), name: property.getName() };
+                }
+                // Resolve default value, required and typeNode
+                let required = false;
+                const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
+                if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.MinusToken) {
+                    required = true;
+                }
+                else if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.QuestionToken) {
+                    required = false;
+                }
+                // Push property
+                return {
+                    name: property.getName(),
+                    required,
+                    deprecated: false,
+                    type: new TypeNodeResolver(typeNode, this.current, this.typeNode, this.context, this.referencer).resolve(),
+                    validators: {},
+                };
+            });
+            return {
+                typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
+                properties,
+            };
+        }
+        if (ts.isConditionalTypeNode(this.typeNode) &&
+            this.referencer &&
+            ts.isTypeReferenceNode(this.referencer)) {
+            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
+            if (type.aliasSymbol) {
+                let declaration = type.aliasSymbol.declarations[0];
+                if (declaration.name) {
+                    declaration = this.getModelTypeDeclaration(declaration.name);
+                }
+                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
+                return this.handleCachingAndCircularReferences(name, () => {
+                    if (ts.isTypeAliasDeclaration(declaration)) {
+                        // Note: I don't understand why typescript lose type for `this.referencer` (from above with isTypeReferenceNode())
+                        return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
+                    }
+                    if (ts.isEnumDeclaration(declaration)) {
+                        return this.getEnumerateType(declaration.name);
+                    }
+                    throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
+                });
+            }
+            if (type.isClassOrInterface()) {
+                let declaration = type.symbol.declarations[0];
+                if (declaration.name) {
+                    declaration = this.getModelTypeDeclaration(declaration.name);
+                }
+                const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
+                return this.handleCachingAndCircularReferences(name, () => this.getModelReference(declaration, this.current.typeChecker.typeToString(type)));
+            }
+            try {
+                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
+            }
+            catch {
+                throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
+            }
+        }
+        if (ts.isTypeOperatorNode(this.typeNode)) {
+            if (this.typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
+                const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
+                try {
+                    return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
+                }
+                catch (err) {
+                    const indexedTypeName = this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.type));
+                    throw new error_1.ResolverError(`Could not determine the keys on ${indexedTypeName}`, this.typeNode);
+                }
+            }
+            if (this.typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) {
+                return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
+            }
+        }
+        if (ts.isIndexedAccessTypeNode(this.typeNode) &&
+            (this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword ||
+                this.typeNode.indexType.kind === ts.SyntaxKind.StringKeyword)) {
+            const numberIndexType = this.typeNode.indexType.kind === ts.SyntaxKind.NumberKeyword;
+            const objectType = this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType);
+            const type = numberIndexType ? objectType.getNumberIndexType() : objectType.getStringIndexType();
+            if (type === undefined) {
+                throw new error_1.ResolverError(`Could not determine ${numberIndexType ? 'number' : 'string'} index on ${this.current.typeChecker.typeToString(objectType)}`, this.typeNode);
+            }
+            return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
+        }
+        if (ts.isIndexedAccessTypeNode(this.typeNode) &&
+            ts.isLiteralTypeNode(this.typeNode.indexType) &&
+            (ts.isStringLiteral(this.typeNode.indexType.literal) || ts.isNumericLiteral(this.typeNode.indexType.literal))) {
+            const hasType = (node) => node !== undefined &&
+                Object.prototype.hasOwnProperty.call(node, 'type');
+            const symbol = this.current.typeChecker.getPropertyOfType(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType), this.typeNode.indexType.literal.text);
+            if (symbol === undefined) {
+                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType))}`, this.typeNode);
+            }
+            if (hasType(symbol.valueDeclaration) && symbol.valueDeclaration.type) {
+                return new TypeNodeResolver(symbol.valueDeclaration.type, this.current, this.typeNode, this.context, this.referencer).resolve();
+            }
+            const declaration = this.current.typeChecker.getTypeOfSymbolAtLocation(symbol, this.typeNode.objectType);
+            try {
+                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
+            }
+            catch {
+                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined)))}`, this.typeNode);
+            }
+        }
+        if (this.typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
+            const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
+            if (type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral())) {
+                return {
+                    typeName: constants_1.TypeName.ENUM,
+                    members: type.types.map((stringLiteralType) => stringLiteralType.value),
+                };
+            }
+            throw new error_1.ResolverError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode);
+        }
+        if (ts.isParenthesizedTypeNode(this.typeNode)) {
+            return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
+        }
+        if (this.typeNode.kind !== ts.SyntaxKind.TypeReference) {
+            throw new error_1.ResolverError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode);
+        }
+        const typeReference = this.typeNode;
+        if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
+            // Special Utility Type
+            if (typeReference.typeName.text === 'Record') {
+                return {
+                    additionalProperties: new TypeNodeResolver(typeReference.typeArguments[1], this.current, this.parentNode, this.context).resolve(),
+                    typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
+                    properties: [],
+                };
+            }
+            const specialReference = TypeNodeResolver.resolveSpecialReference(typeReference.typeName);
+            if (typeof specialReference !== 'undefined') {
+                return specialReference;
+            }
+            if (typeReference.typeName.text === 'Date') {
+                return this.getDateType(this.parentNode);
+            }
+            if (typeReference.typeName.text === 'Buffer' ||
+                typeReference.typeName.text === 'Readable') {
+                return { typeName: constants_1.TypeName.BUFFER };
+            }
+            if (typeReference.typeName.text === 'Array' &&
+                typeReference.typeArguments &&
+                typeReference.typeArguments.length >= 1) {
+                return {
+                    typeName: constants_1.TypeName.ARRAY,
+                    elementType: new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve(),
+                };
+            }
+            if (typeReference.typeName.text === 'Promise' &&
+                typeReference.typeArguments &&
+                typeReference.typeArguments.length === 1) {
+                return new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve();
+            }
+            if (typeReference.typeName.text === 'String') {
+                return { typeName: constants_1.TypeName.STRING };
+            }
+            if (this.context[typeReference.typeName.text]) {
+                return new TypeNodeResolver(this.context[typeReference.typeName.text], this.current, this.parentNode, this.context).resolve();
+            }
+        }
+        const referenceType = this.getReferenceType(typeReference);
+        this.current.addReferenceType(referenceType);
+        return referenceType;
+    }
+    // ------------------------------------------------------------------------
+    // Utility Type(s)
+    // ------------------------------------------------------------------------
+    static isSupportedUtilityType(typeName) {
+        if (typeof typeName === 'undefined') {
+            return false;
+        }
+        return ['NonNullable', 'Pick', 'Omit', 'Partial', 'Readonly', 'Record', 'Required'].indexOf(typeof typeName !== 'string' ? typeName.text : typeName) !== -1;
+    }
+    static getUtilityTypeOptions(typeArguments) {
+        const utilityOptions = {
+            keys: [],
+        };
+        if (typeArguments.length >= 2) {
+            if (ts.isUnionTypeNode(typeArguments[1])) {
+                const args = typeArguments[1].types;
+                for (let i = 0; i < args.length; i++) {
+                    if (ts.isLiteralTypeNode(args[i])) {
+                        utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(args[i]));
+                    }
+                }
+            }
+            if (ts.isLiteralTypeNode(typeArguments[1])) {
+                utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(typeArguments[1]));
+            }
+        }
+        return utilityOptions;
+    }
+    filterUtilityProperties(properties, utilityType, utilityOptions) {
+        if (typeof utilityType === 'undefined' || typeof utilityOptions === 'undefined') {
+            return properties;
+        }
+        return properties
+            .filter((property) => {
+            const name = typeof property.name !== 'string' ? property.name.text : property.name;
+            switch (utilityType) {
+                case 'Pick':
+                    return utilityOptions.keys.indexOf(name) !== -1;
+                case 'Omit':
+                    return utilityOptions.keys.indexOf(name) === -1;
+            }
+            return true;
+        })
+            .map((property) => {
+            if ((0, utils_1.hasOwnProperty)(property, 'required')) {
+                switch (utilityType) {
+                    case 'Partial':
+                        property.required = false;
+                        break;
+                    case 'Required':
+                    case 'NonNullable':
+                        property.required = true;
+                        break;
+                }
+            }
+            return property;
+        });
+    }
+    static resolveSpecialReference(node) {
+        switch (node.text) {
+            case 'Buffer':
+            case 'DownloadBinaryData':
+            case 'DownloadResource':
+                return { typeName: constants_1.TypeName.BUFFER };
+            default:
+                return undefined;
+        }
+    }
+    static getLiteralValue(typeNode) {
+        let value;
+        switch (typeNode.literal.kind) {
+            case ts.SyntaxKind.TrueKeyword:
+                value = true;
+                break;
+            case ts.SyntaxKind.FalseKeyword:
+                value = false;
+                break;
+            case ts.SyntaxKind.StringLiteral:
+                value = typeNode.literal.text;
+                break;
+            case ts.SyntaxKind.NumericLiteral:
+                value = parseFloat(typeNode.literal.text);
+                break;
+            case ts.SyntaxKind.NullKeyword:
+                value = null;
+                break;
+            default:
+                if (Object.prototype.hasOwnProperty.call(typeNode.literal, 'text')) {
+                    value = typeNode.literal.text;
+                }
+                else {
+                    throw new error_1.ResolverError(`Couldn't resolve literal node: ${typeNode.literal.getText()}`);
+                }
+        }
+        return value;
+    }
+    getPrimitiveType(typeNode, parentNode) {
+        if (!typeNode) {
+            return {
+                typeName: constants_1.TypeName.VOID,
+            };
+        }
+        const resolvedType = this.attemptToResolveKindToPrimitive(typeNode.kind);
+        if (typeof resolvedType === 'undefined') {
+            return undefined;
+        }
+        if (resolvedType === 'number') {
+            if (!parentNode) {
+                return { typeName: constants_1.TypeName.DOUBLE };
+            }
+            const lookupTags = [
+                'isInt',
+                'isLong',
+                'isFloat',
+                'isDouble',
+            ];
+            const tags = (0, utils_1.getJSDocTagNames)(parentNode)
+                .filter((name) => lookupTags.some((m) => m.toLowerCase() === name.toLowerCase()))
+                .map((name) => name.toLowerCase());
+            const decoratorIds = [
+                decorator_1.DecoratorID.IS_INT,
+                decorator_1.DecoratorID.IS_LONG,
+                decorator_1.DecoratorID.IS_FLOAT,
+                decorator_1.DecoratorID.IS_DOUBLE,
+            ];
+            let decoratorID;
+            for (let i = 0; i < decoratorIds.length; i++) {
+                const decorator = this.current.decoratorResolver.match(decoratorIds[i], parentNode);
+                if (decorator) {
+                    decoratorID = decoratorIds[i];
+                    break;
+                }
+            }
+            if (!decoratorID && tags.length === 0) {
+                return { typeName: constants_1.TypeName.DOUBLE };
+            }
+            switch (decoratorID || tags[0]) {
+                case decorator_1.DecoratorID.IS_INT:
+                case 'isint':
+                    return { typeName: constants_1.TypeName.INTEGER };
+                case decorator_1.DecoratorID.IS_LONG:
+                case 'islong':
+                    return { typeName: constants_1.TypeName.LONG };
+                case decorator_1.DecoratorID.IS_FLOAT:
+                case 'isfloat':
+                    return { typeName: constants_1.TypeName.FLOAT };
+                case decorator_1.DecoratorID.IS_DOUBLE:
+                case 'isdouble':
+                    return { typeName: constants_1.TypeName.DOUBLE };
+                default:
+                    return { typeName: constants_1.TypeName.DOUBLE };
+            }
+        }
+        else if (resolvedType === 'string') {
+            return {
+                typeName: constants_1.TypeName.STRING,
+            };
+        }
+        else if (resolvedType === 'boolean') {
+            return {
+                typeName: constants_1.TypeName.BOOLEAN,
+            };
+        }
+        else if (resolvedType === 'void') {
+            return {
+                typeName: constants_1.TypeName.VOID,
+            };
+        }
+        else {
+            // todo: should not occur
+            return {
+                typeName: resolvedType,
+            };
+        }
+    }
+    getDateType(parentNode) {
+        if (!parentNode) {
+            return { typeName: constants_1.TypeName.DATETIME };
+        }
+        const tags = (0, utils_1.getJSDocTagNames)(parentNode).filter((name) => ['isDate', 'isDateTime'].some((m) => m === name));
+        if (tags.length === 0) {
+            return { typeName: constants_1.TypeName.DATETIME };
+        }
+        switch (tags[0]) {
+            case 'isDate':
+                return { typeName: constants_1.TypeName.DATE };
+            default:
+                return { typeName: constants_1.TypeName.DATETIME };
+        }
+    }
+    static getDesignatedModels(nodes, typeName) {
+        return nodes;
+    }
+    getEnumerateType(typeName) {
+        const enumName = typeName.text;
+        let enumNodes = this.current.nodes.filter((node) => node.kind === ts.SyntaxKind.EnumDeclaration && node.name.text === enumName);
+        if (!enumNodes.length) {
+            return undefined;
+        }
+        enumNodes = TypeNodeResolver.getDesignatedModels(enumNodes, enumName);
+        if (enumNodes.length > 1) {
+            throw new error_1.ResolverError(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
+        }
+        const enumDeclaration = enumNodes[0];
+        const isNotUndefined = (item) => item !== undefined;
+        const enums = enumDeclaration.members.map(this.current.typeChecker.getConstantValue.bind(this.current.typeChecker)).filter(isNotUndefined);
+        const enumNames = enumDeclaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
+        return {
+            typeName: constants_1.TypeName.REF_ENUM,
+            description: this.getNodeDescription(enumDeclaration),
+            members: enums,
+            memberNames: enumNames,
+            refName: enumName,
+            deprecated: (0, utils_1.hasJSDocTag)(enumDeclaration, utils_1.JSDocTagName.DEPRECATED),
+        };
+    }
+    getReferenceType(node) {
+        let type;
+        if (ts.isTypeReferenceNode(node)) {
+            type = node.typeName;
+        }
+        else if (ts.isExpressionWithTypeArguments(node)) {
+            type = node.expression;
+        }
+        else {
+            throw new error_1.ResolverError('Can\'t resolve reference type.');
+        }
+        // Can't invoke getText on Synthetic Nodes
+        let resolvableName = node.pos !== -1 ? node.getText() : type.text;
+        if (node.pos === -1 && 'typeArguments' in node && Array.isArray(node.typeArguments)) {
+            // Add typeArguments for Synthetic nodes (e.g. Record<> in TestClassModel.indexedResponse)
+            const argumentsString = node.typeArguments
+                .map((arg) => {
+                if (ts.isLiteralTypeNode(arg)) {
+                    return `'${String(TypeNodeResolver.getLiteralValue(arg))}'`;
+                }
+                const resolvedType = this.attemptToResolveKindToPrimitive(arg.kind);
+                if (typeof resolvedType === 'undefined') {
+                    return 'any';
+                }
+                return resolvedType;
+            });
+            resolvableName += `<${argumentsString.join(', ')}>`;
+        }
+        const name = this.contextualizedName(resolvableName);
+        // Handle Utility Types
+        const identifierName = type.text;
+        const utilityTypeSupported = TypeNodeResolver.isSupportedUtilityType(identifierName);
+        const utilityType = utilityTypeSupported ? identifierName : undefined;
+        let utilityOptions = {
+            keys: [],
+        };
+        if (utilityTypeSupported) {
+            const { typeArguments } = type.parent;
+            if (ts.isTypeReferenceNode(typeArguments[0])) {
+                type = typeArguments[0].typeName;
+            }
+            else if (ts.isExpressionWithTypeArguments(typeArguments[0])) {
+                type = typeArguments[0].expression;
+            }
+            else {
+                throw new error_1.ResolverError('Can\'t resolve Reference type.');
+            }
+            utilityOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
+        }
+        else {
+            this.typeArgumentsToContext(node, type, this.context);
+        }
+        try {
+            const existingType = localReferenceTypeCache[name];
+            if (existingType) {
+                return existingType;
+            }
+            const refEnumType = this.getEnumerateType(type);
+            if (refEnumType) {
+                localReferenceTypeCache[name] = refEnumType;
+                return refEnumType;
+            }
+            if (inProgressTypes[name]) {
+                return this.createCircularDependencyResolver(name);
+            }
+            inProgressTypes[name] = true;
+            const declaration = this.getModelTypeDeclaration(type);
+            let referenceType;
+            if (ts.isTypeAliasDeclaration(declaration)) {
+                referenceType = this.getTypeAliasReference(declaration, name, node);
+            }
+            else if (ts.isEnumMember(declaration)) {
+                referenceType = {
+                    typeName: constants_1.TypeName.REF_ENUM,
+                    refName: TypeNodeResolver.getRefTypeName(name, utilityType),
+                    members: [this.current.typeChecker.getConstantValue(declaration)],
+                    memberNames: [declaration.name.getText()],
+                    deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
+                };
+            }
+            else {
+                // todo: dont cast handle property-signature
+                referenceType = this.getModelReference(declaration, name, utilityType, utilityOptions);
+            }
+            localReferenceTypeCache[name] = referenceType;
+            return referenceType;
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(`There was a problem resolving type of '${name}'.`);
+            throw err;
+        }
+    }
+    getTypeAliasReference(declaration, name, referencer) {
+        const refName = TypeNodeResolver.getRefTypeName(name);
+        let type;
+        if (declaration.type.kind === ts.SyntaxKind.TypeReference) {
+            const referenceType = this.getReferenceType(declaration.type);
+            if (referenceType.refName === refName) {
+                return referenceType;
+            }
+        }
+        if (typeof type === 'undefined') {
+            type = new TypeNodeResolver(declaration.type, this.current, declaration, this.context, this.referencer || referencer).resolve();
+        }
+        const example = this.getNodeExample(declaration);
+        return {
+            typeName: constants_1.TypeName.REF_ALIAS,
+            default: (0, utils_1.getJSDocTagComment)(declaration, utils_1.JSDocTagName.DEFAULT),
+            description: this.getNodeDescription(declaration),
+            refName,
+            format: TypeNodeResolver.getNodeFormat(declaration),
+            type,
+            validators: (0, utils_1.getDeclarationValidators)(declaration) || {},
+            deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
+            ...(example && { example }),
+        };
+    }
+    getModelReference(modelType, name, utilityType, utilityOptions) {
+        const example = this.getNodeExample(modelType);
+        const description = this.getNodeDescription(modelType);
+        const deprecated = (0, utils_1.hasJSDocTag)(modelType, utils_1.JSDocTagName.DEPRECATED) ||
+            !!this.current.decoratorResolver.match(decorator_1.DecoratorID.DEPRECATED, modelType);
+        // Handle toJSON methods
+        if (!modelType.name) {
+            throw new error_1.ResolverError('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;
+            if (!nodeType) {
+                const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
+                const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
+                nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
+            }
+            return {
+                refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`,
+                typeName: constants_1.TypeName.REF_ALIAS,
+                description,
+                type: new TypeNodeResolver(nodeType, this.current).resolve(),
+                deprecated,
+                validators: {},
+                ...(example && { example }),
+            };
+        }
+        const properties = this.getModelProperties(modelType, undefined, utilityType, utilityOptions);
+        const additionalProperties = this.getModelAdditionalProperties(modelType);
+        const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
+        const referenceType = {
+            additionalProperties,
+            typeName: constants_1.TypeName.REF_OBJECT,
+            description,
+            properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions),
+            refName: TypeNodeResolver.getRefTypeName(name, utilityType),
+            deprecated,
+            ...(example && { example }),
+        };
+        referenceType.properties = referenceType.properties.concat(properties);
+        return referenceType;
+    }
+    static getRefTypeName(name, utilityType) {
+        return encodeURIComponent(name
+            .replace(/<|>/g, '_')
+            .replace(/\s+/g, '')
+            .replace(/,/g, '.')
+            .replace(/'([^']*)'/g, '$1')
+            .replace(/"([^"]*)"/g, '$1')
+            .replace(/&/g, typeof utilityType !== 'undefined' ? '--' : '-and-')
+            .replace(/\|/g, typeof utilityType !== 'undefined' ? '--' : '-or-')
+            .replace(/\[\]/g, '-array')
+            .replace(/{|}/g, '_') // SuccessResponse_{indexesCreated-number}_ -> SuccessResponse__indexesCreated-number__
+            .replace(/([a-z]+):([a-z]+)/gi, '$1-$2') // SuccessResponse_indexesCreated:number_ -> SuccessResponse_indexesCreated-number_
+            .replace(/;/g, '--')
+            .replace(/([a-z]+)\[([a-z]+)\]/gi, '$1-at-$2') // Partial_SerializedDatasourceWithVersion[format]_ -> Partial_SerializedDatasourceWithVersion~format~_,
+            .replace(/_/g, '')
+            .replace(/-/g, ''));
+    }
+    contextualizedName(name) {
+        return Object.entries(this.context).reduce((acc, [key, entry]) => acc
+            .replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `<$1${entry.getText()}$3>`)
+            .replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, 'g'), `<$1${entry.getText()}$3,`)
+            .replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `,$1${entry.getText()}$3>`)
+            .replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, 'g'), `<$1${entry.getText()}$3<`), name);
+    }
+    handleCachingAndCircularReferences(name, declarationResolver) {
+        try {
+            const existingType = localReferenceTypeCache[name];
+            if (existingType) {
+                return existingType;
+            }
+            if (inProgressTypes[name]) {
+                return this.createCircularDependencyResolver(name);
+            }
+            inProgressTypes[name] = true;
+            const reference = declarationResolver();
+            localReferenceTypeCache[name] = reference;
+            this.current.addReferenceType(reference);
+            return reference;
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(`There was a problem resolving type of '${name}'.`);
+            throw err;
+        }
+    }
+    createCircularDependencyResolver(refName) {
+        const referenceType = {
+            typeName: constants_1.TypeName.REF_OBJECT,
+            refName,
+        };
+        this.current.registerDependencyResolver((referenceTypes) => {
+            const realReferenceType = referenceTypes[refName];
+            if (!realReferenceType) {
+                return;
+            }
+            referenceType.description = realReferenceType.description;
+            if (realReferenceType.typeName === 'refObject' && referenceType.typeName === 'refObject') {
+                referenceType.properties = realReferenceType.properties;
+            }
+            referenceType.typeName = realReferenceType.typeName;
+            referenceType.refName = realReferenceType.refName;
+        });
+        return referenceType;
+    }
+    static nodeIsUsable(node) {
+        switch (node.kind) {
+            case ts.SyntaxKind.InterfaceDeclaration:
+            case ts.SyntaxKind.ClassDeclaration:
+            case ts.SyntaxKind.TypeAliasDeclaration:
+            case ts.SyntaxKind.EnumDeclaration:
+            case ts.SyntaxKind.EnumMember:
+                return true;
+            default:
+                return false;
+        }
+    }
+    getModelTypeDeclaration(type) {
+        let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
+        const symbol = this.getSymbolAtLocation(type);
+        const declarations = symbol.getDeclarations();
+        if (declarations.length === 0) {
+            throw new error_1.ResolverError(`No models found for referenced type ${typeName}.`);
+        }
+        if (symbol.escapedName !== typeName && symbol.escapedName !== 'default') {
+            typeName = symbol.escapedName;
+        }
+        let modelTypes = declarations.filter((node) => {
+            if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) {
+                return false;
+            }
+            const modelTypeDeclaration = node;
+            return modelTypeDeclaration.name?.text === typeName;
+        });
+        if (!modelTypes.length) {
+            throw new error_1.ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
+        }
+        if (modelTypes.length > 1) {
+            // remove types that are from typescript e.g. 'Account'
+            modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile()
+                .fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules/typescript') <= -1);
+            modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
+        }
+        if (modelTypes.length > 1) {
+            const conflicts = modelTypes.map((modelType) => modelType.getSourceFile().fileName).join('"; "');
+            throw new error_1.ResolverError(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
+        }
+        return modelTypes[0];
+    }
+    hasFlag(type, flag) {
+        return (type.flags & flag) === flag;
+    }
+    getSymbolAtLocation(type) {
+        const symbol = this.current.typeChecker.getSymbolAtLocation(type) || type.symbol;
+        // resolve alias if it is an alias, otherwise take symbol directly
+        return (symbol &&
+            this.hasFlag(symbol, ts.SymbolFlags.Alias) &&
+            this.current.typeChecker.getAliasedSymbol(symbol)) || symbol;
+    }
+    getModelProperties(node, overrideToken, utilityType, utilityOptions) {
+        const isIgnored = (e) => (0, utils_1.hasJSDocTag)(e, utils_1.JSDocTagName.IGNORE);
+        // Interface model
+        if (ts.isInterfaceDeclaration(node)) {
+            return node.members.filter((member) => !isIgnored(member) &&
+                ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
+        }
+        // Class model
+        let properties = node.members
+            .filter((member) => !isIgnored(member) &&
+            member.kind === ts.SyntaxKind.PropertyDeclaration &&
+            !this.hasStaticModifier(member) &&
+            this.hasPublicModifier(member));
+        const classConstructor = node.members.find((member) => ts.isConstructorDeclaration(member));
+        if (classConstructor && classConstructor.parameters) {
+            const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
+            properties.push(...constructorProperties);
+        }
+        properties = this.filterUtilityProperties(properties, utilityType, utilityOptions);
+        return properties.map((property) => this.propertyFromDeclaration(property, overrideToken, utilityType));
+    }
+    propertyFromSignature(propertySignature, overrideToken) {
+        const identifier = propertySignature.name;
+        if (!propertySignature.type) {
+            throw new error_1.ResolverError('No valid type found for property declaration.');
+        }
+        let required = !propertySignature.questionToken;
+        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
+            required = true;
+        }
+        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
+            required = false;
+        }
+        const property = {
+            deprecated: (0, utils_1.hasJSDocTag)(propertySignature, utils_1.JSDocTagName.DEPRECATED),
+            default: (0, utils_1.getJSDocTagComment)(propertySignature, utils_1.JSDocTagName.DEFAULT),
+            description: this.getNodeDescription(propertySignature),
+            example: this.getNodeExample(propertySignature),
+            extensions: this.getNodeExtensions(propertySignature),
+            format: TypeNodeResolver.getNodeFormat(propertySignature),
+            name: identifier.text,
+            required,
+            type: new TypeNodeResolver(propertySignature.type, this.current, propertySignature.type.parent, this.context, propertySignature.type).resolve(),
+            validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
+        };
+        return property;
+    }
+    propertyFromDeclaration(propertyDeclaration, overrideToken, utilityType) {
+        const identifier = propertyDeclaration.name;
+        let typeNode = propertyDeclaration.type;
+        if (!typeNode) {
+            const tsType = this.current.typeChecker.getTypeAtLocation(propertyDeclaration);
+            typeNode = this.current.typeChecker.typeToTypeNode(tsType, undefined, ts.NodeBuilderFlags.NoTruncation);
+        }
+        if (!typeNode) {
+            throw new error_1.ResolverError('No valid type found for property declaration.');
+        }
+        const type = new TypeNodeResolver(typeNode, this.current, propertyDeclaration, this.context, typeNode).resolve();
+        let required = !propertyDeclaration.questionToken && !propertyDeclaration.initializer;
+        if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
+            required = true;
+        }
+        else if (overrideToken && overrideToken.kind === ts.SyntaxKind.QuestionToken) {
+            required = false;
+        }
+        if (typeof utilityType !== 'undefined') {
+            if (utilityType === 'Partial') {
+                required = false;
+            }
+            if (utilityType === 'Required') {
+                required = true;
+            }
+        }
+        const property = {
+            deprecated: (0, utils_1.hasJSDocTag)(propertyDeclaration, utils_1.JSDocTagName.DEPRECATED),
+            default: (0, utils_1.getInitializerValue)(propertyDeclaration.initializer, this.current.typeChecker),
+            description: this.getNodeDescription(propertyDeclaration),
+            example: this.getNodeExample(propertyDeclaration),
+            extensions: this.getNodeExtensions(propertyDeclaration),
+            format: TypeNodeResolver.getNodeFormat(propertyDeclaration),
+            name: identifier.text,
+            required,
+            type,
+            validators: (0, utils_1.getDeclarationValidators)(propertyDeclaration) || {},
+        };
+        return property;
+    }
+    getModelAdditionalProperties(node) {
+        if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
+            const indexMember = node.members.find((member) => member.kind === ts.SyntaxKind.IndexSignature);
+            if (!indexMember) {
+                return undefined;
+            }
+            const indexSignatureDeclaration = indexMember;
+            const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
+            if (indexType.typeName !== 'string') {
+                throw new error_1.ResolverError('Only string indexers are supported.', this.typeNode);
+            }
+            return new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
+        }
+        return undefined;
+    }
+    typeArgumentsToContext(type, targetEntity, context) {
+        // this.context = {};
+        const declaration = this.getModelTypeDeclaration(targetEntity);
+        if (typeof declaration === 'undefined' || !('typeParameters' in declaration)) {
+            return context;
+        }
+        const { typeParameters } = declaration;
+        if (typeParameters) {
+            for (let index = 0; index < typeParameters.length; index++) {
+                const typeParameter = typeParameters[index];
+                const typeArg = type.typeArguments && type.typeArguments[index];
+                let resolvedType;
+                // Argument may be a forward reference from context
+                if (typeArg && ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && context[typeArg.typeName.text]) {
+                    resolvedType = context[typeArg.typeName.text];
+                }
+                else if (typeArg) {
+                    resolvedType = typeArg;
+                }
+                else if (typeParameter.default) {
+                    resolvedType = typeParameter.default;
+                }
+                else {
+                    throw new error_1.ResolverError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
+                }
+                this.context = {
+                    ...this.context,
+                    [typeParameter.name.text]: resolvedType,
+                };
+            }
+        }
+        return context;
+    }
+    getModelInheritedProperties(modelTypeDeclaration) {
+        let properties = [];
+        const { heritageClauses } = modelTypeDeclaration;
+        if (!heritageClauses) {
+            return properties;
+        }
+        heritageClauses.forEach((clause) => {
+            if (!clause.types) {
+                return;
+            }
+            clause.types.forEach((t) => {
+                const baseEntityName = t.expression;
+                // create subContext
+                const resetCtx = this.typeArgumentsToContext(t, baseEntityName, this.context);
+                const referenceType = this.getReferenceType(t);
+                if (referenceType) {
+                    if ((0, type_1.isRefAliasType)(referenceType)) {
+                        let type = referenceType;
+                        while ((0, type_1.isRefAliasType)(type)) {
+                            type = type.type;
+                        }
+                        if (type.typeName === constants_1.TypeName.REF_OBJECT) {
+                            properties = [...properties, ...type.properties];
+                        }
+                        else if (type.typeName === constants_1.TypeName.NESTED_OBJECT_LITERAL) {
+                            properties = [...properties, ...type.properties];
+                        }
+                    }
+                    if ((0, type_1.isRefObjectType)(referenceType)) {
+                        referenceType.properties.forEach((property) => properties.push(property));
+                    }
+                }
+                // reset subContext
+                this.context = resetCtx;
+            });
+        });
+        return properties;
+    }
+    hasPublicModifier(node) {
+        if (!ts.canHaveModifiers(node)) {
+            return true;
+        }
+        const modifiers = ts.getModifiers(node);
+        if (!modifiers) {
+            return true;
+        }
+        return modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword);
+    }
+    hasStaticModifier(node) {
+        if (!ts.canHaveModifiers(node)) {
+            return false;
+        }
+        const modifiers = ts.getModifiers(node);
+        return modifiers && modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
+    }
+    isAccessibleParameter(node) {
+        // No modifiers
+        if (!ts.canHaveModifiers(node)) {
+            return false;
+        }
+        const modifiers = ts.getModifiers(node);
+        if (!modifiers) {
+            return false;
+        }
+        // public || public readonly
+        if (modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
+            return true;
+        }
+        // readonly, not private readonly, not public readonly
+        const isReadonly = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
+        const isProtectedOrPrivate = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ProtectedKeyword ||
+            modifier.kind === ts.SyntaxKind.PrivateKeyword);
+        return isReadonly && !isProtectedOrPrivate;
+    }
+    getNodeDescription(node) {
+        const symbol = this.current.typeChecker.getSymbolAtLocation(node.name);
+        if (!symbol) {
+            return undefined;
+        }
+        /**
+         * TODO: Workaround for what seems like a bug in the compiler
+         * Warrants more investigation and possibly a PR against typescript
+         */
+        if (node.kind === ts.SyntaxKind.Parameter) {
+            // TypeScript won't parse jsdoc if the flag is 4, i.e. 'Property'
+            symbol.flags = 0;
+        }
+        const comments = symbol.getDocumentationComment(this.current.typeChecker);
+        if (comments.length) {
+            return ts.displayPartsToString(comments);
+        }
+        return undefined;
+    }
+    static getNodeFormat(node) {
+        return (0, utils_1.getJSDocTagComment)(node, utils_1.JSDocTagName.FORMAT);
+    }
+    getNodeExample(node) {
+        const example = (0, utils_1.getJSDocTagComment)(node, utils_1.JSDocTagName.EXAMPLE);
+        if (example) {
+            try {
+                return JSON.parse(example);
+            }
+            catch {
+                // do nothing
+            }
+        }
+        return undefined;
+    }
+    getNodeExtensions(node) {
+        return (0, extension_1.getNodeExtensions)(node, this.current.decoratorResolver);
+    }
+}
+exports.TypeNodeResolver = TypeNodeResolver;
 //# sourceMappingURL=module.js.map