@trapi/metadata 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/resolver/index.js

@@ -20,7 +20,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
 __exportStar(require("./error"), exports);
+__exportStar(require("./extension"), exports);
 __exportStar(require("./module"), exports);
 __exportStar(require("./type"), exports);
 //# sourceMappingURL=index.js.map

package/dist/resolver/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resolver/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;;;;;;;;;;;AAEH,0CAAwB;AACxB,2CAAyB;AACzB,yCAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resolver/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;;;;;;;;;;;AAEH,8CAA4B;AAC5B,0CAAwB;AACxB,8CAA4B;AAC5B,2CAAyB;AACzB,yCAAuB"}

package/dist/resolver/module.d.ts

@@ -1,6 +1,8 @@
 import * as ts from 'typescript';
 import type { MetadataGenerator } from '../generator';
-import type { TypeVariant } from './type';
+import type { Extension } from './extension';
+import type { Type } from './type';
+type UsableDeclaration = ts.InterfaceDeclaration | ts.ClassDeclaration | ts.PropertySignature | ts.TypeAliasDeclaration | ts.EnumMember;
 interface TypeNodeResolverContext {
     [name: string]: ts.TypeReferenceNode | ts.TypeNode;
 }
@@ -12,7 +14,7 @@ export declare class TypeNodeResolver {
     private readonly referencer;
     constructor(typeNode: ts.TypeNode, current: MetadataGenerator, parentNode?: ts.Node, context?: TypeNodeResolverContext, referencer?: ts.TypeNode);
     static clearCache(): void;
-    resolve(): TypeVariant;
+    resolve(): Type;
     private static isSupportedUtilityType;
     private static getUtilityTypeOptions;
     private filterUtilityProperties;
@@ -46,6 +48,7 @@ export declare class TypeNodeResolver {
     private getNodeDescription;
     private static getNodeFormat;
     private getNodeExample;
+    protected getNodeExtensions(node: UsableDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.EnumDeclaration): Extension[];
 }
 export {};
 //# sourceMappingURL=module.d.ts.map

package/dist/resolver/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/resolver/module.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAWtD,OAAO,KAAK,EAcR,WAAW,EAEd,MAAM,QAAQ,CAAC;AAgBhB,UAAU,uBAAuB;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,iBAAiB,GAAG,EAAE,CAAC,QAAQ,CAAC;CACtD;AAcD,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IAExC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAU;IAEtC,OAAO,CAAC,OAAO,CAA0B;IAEzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;gBAGtC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EACrB,OAAO,EAAE,iBAAiB,EAC1B,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,EACpB,OAAO,CAAC,EAAE,uBAAuB,EACjC,UAAU,CAAC,EAAE,EAAE,CAAC,QAAQ;WASd,UAAU;IAUjB,OAAO,IAAI,WAAW;IA8Z7B,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAKrC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAuBpC,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAWtC,OAAO,CAAC,MAAM,CAAC,eAAe;IA4B9B,OAAO,CAAC,gBAAgB;IAoFxB,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAIlC,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,gBAAgB;IAkGxB,OAAO,CAAC,qBAAqB;IAmC7B,OAAO,CAAC,iBAAiB;IAoEzB,OAAO,CAAC,MAAM,CAAC,cAAc;IAqB7B,OAAO,CAAC,+BAA+B,CAWrC;IAEF,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,kCAAkC;IA2B1C,OAAO,CAAC,gCAAgC;IAuBxC,OAAO,CAAC,MAAM,CAAC,YAAY;IAa3B,OAAO,CAAC,uBAAuB;IA+C/B,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,kBAAkB;IAoC1B,OAAO,CAAC,qBAAqB;IAkC7B,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,sBAAsB;IAwC9B,OAAO,CAAC,2BAA2B;IAmDnC,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,MAAM,CAAC,aAAa;IAM5B,OAAO,CAAC,cAAc;CAazB"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/resolver/module.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAY7C,OAAO,KAAK,EAcR,IAAI,EAEP,MAAM,QAAQ,CAAC;AAShB,KAAK,iBAAiB,GAAG,EAAE,CAAC,oBAAoB,GAChD,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,iBAAiB,GACpB,EAAE,CAAC,oBAAoB,GACvB,EAAE,CAAC,UAAU,CAAC;AAEd,UAAU,uBAAuB;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,EAAE,CAAC,iBAAiB,GAAG,EAAE,CAAC,QAAQ,CAAC;CACtD;AAOD,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IAExC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAU;IAEtC,OAAO,CAAC,OAAO,CAA0B;IAEzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;gBAGtC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EACrB,OAAO,EAAE,iBAAiB,EAC1B,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,EACpB,OAAO,CAAC,EAAE,uBAAuB,EACjC,UAAU,CAAC,EAAE,EAAE,CAAC,QAAQ;WASd,UAAU;IAUjB,OAAO,IAAI,IAAI;IAibtB,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAKrC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAuBpC,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAWtC,OAAO,CAAC,MAAM,CAAC,eAAe;IA4B9B,OAAO,CAAC,gBAAgB;IAoFxB,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAIlC,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,gBAAgB;IAkGxB,OAAO,CAAC,qBAAqB;IAmC7B,OAAO,CAAC,iBAAiB;IAoEzB,OAAO,CAAC,MAAM,CAAC,cAAc;IAqB7B,OAAO,CAAC,+BAA+B,CAWrC;IAEF,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,kCAAkC;IA2B1C,OAAO,CAAC,gCAAgC;IAuBxC,OAAO,CAAC,MAAM,CAAC,YAAY;IAa3B,OAAO,CAAC,uBAAuB;IA+C/B,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,kBAAkB;IAoC1B,OAAO,CAAC,qBAAqB;IAmC7B,OAAO,CAAC,uBAAuB;IAmD/B,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,sBAAsB;IAwC9B,OAAO,CAAC,2BAA2B;IAiDnC,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,MAAM,CAAC,aAAa;IAM5B,OAAO,CAAC,cAAc;IActB,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,oBAAoB,GAAG,EAAE,CAAC,eAAe,GAAI,SAAS,EAAE;CAG7I"}

package/dist/resolver/module.js

@@ -32,13 +32,13 @@ 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 = {};
-function getPropertyValidators(_property) {
-    return {};
-}
 class TypeNodeResolver {
     constructor(typeNode, current, parentNode, context, referencer) {
         this.attemptToResolveKindToPrimitive = (syntaxKind) => {
@@ -77,40 +77,44 @@ class TypeNodeResolver {
         }
         if (this.typeNode.kind === ts.SyntaxKind.NullKeyword) {
             return {
-                typeName: 'enum',
+                typeName: constants_1.TypeName.ENUM,
                 members: [null],
             };
         }
-        if (this.typeNode.kind === ts.SyntaxKind.ArrayType) {
+        if (this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+            return {
+                typeName: constants_1.TypeName.UNDEFINED,
+            };
+        }
+        if (ts.isArrayTypeNode(this.typeNode)) {
             return {
-                typeName: 'array',
+                typeName: constants_1.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());
+            const members = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
             return {
-                typeName: 'union',
-                members: types,
+                typeName: constants_1.TypeName.UNION,
+                members,
             };
         }
         if (ts.isIntersectionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
+            const members = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
             return {
-                typeName: 'intersection',
-                members: types,
+                typeName: constants_1.TypeName.INTERSECTION,
+                members,
             };
         }
         if (this.typeNode.kind === ts.SyntaxKind.AnyKeyword ||
-            this.typeNode.kind === ts.SyntaxKind.UnknownKeyword ||
-            this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+            this.typeNode.kind === ts.SyntaxKind.UnknownKeyword) {
             return {
-                typeName: 'any',
+                typeName: constants_1.TypeName.ANY,
             };
         }
         if (ts.isLiteralTypeNode(this.typeNode)) {
             return {
-                typeName: 'enum',
+                typeName: constants_1.TypeName.ENUM,
                 members: [TypeNodeResolver.getLiteralValue(this.typeNode)],
             };
         }
@@ -122,13 +126,14 @@ class TypeNodeResolver {
                 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: getPropertyValidators(propertySignature) || {},
+                    validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
                 };
                 return [property, ...res];
             }, []);
@@ -137,19 +142,20 @@ class TypeNodeResolver {
             if (indexMember) {
                 const indexSignatureDeclaration = indexMember;
                 const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
-                if (indexType.typeName !== 'string') {
+                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: 'nestedObjectLiteral',
+                typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
                 properties,
             };
         }
-        if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword || ts.isFunctionTypeNode(this.typeNode)) {
-            return { typeName: 'object' };
+        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);
@@ -158,11 +164,15 @@ class TypeNodeResolver {
             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 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()
@@ -197,11 +207,13 @@ class TypeNodeResolver {
                 };
             });
             return {
-                typeName: 'nestedObjectLiteral',
+                typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
                 properties,
             };
         }
-        if (ts.isConditionalTypeNode(this.typeNode) && this.referencer && ts.isTypeReferenceNode(this.referencer)) {
+        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];
@@ -235,19 +247,21 @@ class TypeNodeResolver {
                 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();
+        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);
+                }
             }
-            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.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)) {
@@ -283,7 +297,7 @@ class TypeNodeResolver {
             const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
             if (type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral())) {
                 return {
-                    typeName: 'enum',
+                    typeName: constants_1.TypeName.ENUM,
                     members: type.types.map((stringLiteralType) => stringLiteralType.value),
                 };
             }
@@ -301,7 +315,7 @@ class TypeNodeResolver {
             if (typeReference.typeName.text === 'Record') {
                 return {
                     additionalProperties: new TypeNodeResolver(typeReference.typeArguments[1], this.current, this.parentNode, this.context).resolve(),
-                    typeName: 'nestedObjectLiteral',
+                    typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
                     properties: [],
                 };
             }
@@ -314,13 +328,13 @@ class TypeNodeResolver {
             }
             if (typeReference.typeName.text === 'Buffer' ||
                 typeReference.typeName.text === 'Readable') {
-                return { typeName: 'buffer' };
+                return { typeName: constants_1.TypeName.BUFFER };
             }
             if (typeReference.typeName.text === 'Array' &&
                 typeReference.typeArguments &&
                 typeReference.typeArguments.length >= 1) {
                 return {
-                    typeName: 'array',
+                    typeName: constants_1.TypeName.ARRAY,
                     elementType: new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve(),
                 };
             }
@@ -330,7 +344,7 @@ class TypeNodeResolver {
                 return new TypeNodeResolver(typeReference.typeArguments[0], this.current, this.parentNode, this.context).resolve();
             }
             if (typeReference.typeName.text === 'String') {
-                return { typeName: '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();
@@ -403,7 +417,7 @@ class TypeNodeResolver {
             case 'Buffer':
             case 'DownloadBinaryData':
             case 'DownloadResource':
-                return { typeName: 'buffer' };
+                return { typeName: constants_1.TypeName.BUFFER };
             default:
                 return undefined;
         }
@@ -439,7 +453,7 @@ class TypeNodeResolver {
     getPrimitiveType(typeNode, parentNode) {
         if (!typeNode) {
             return {
-                typeName: 'void',
+                typeName: constants_1.TypeName.VOID,
             };
         }
         const resolvedType = this.attemptToResolveKindToPrimitive(typeNode.kind);
@@ -448,7 +462,7 @@ class TypeNodeResolver {
         }
         if (resolvedType === 'number') {
             if (!parentNode) {
-                return { typeName: 'double' };
+                return { typeName: constants_1.TypeName.DOUBLE };
             }
             const lookupTags = [
                 'isInt',
@@ -474,38 +488,38 @@ class TypeNodeResolver {
                 }
             }
             if (!decoratorID && tags.length === 0) {
-                return { typeName: 'double' };
+                return { typeName: constants_1.TypeName.DOUBLE };
             }
             switch (decoratorID || tags[0]) {
                 case decorator_1.DecoratorID.IS_INT:
                 case 'isint':
-                    return { typeName: 'integer' };
+                    return { typeName: constants_1.TypeName.INTEGER };
                 case decorator_1.DecoratorID.IS_LONG:
                 case 'islong':
-                    return { typeName: 'long' };
+                    return { typeName: constants_1.TypeName.LONG };
                 case decorator_1.DecoratorID.IS_FLOAT:
                 case 'isfloat':
-                    return { typeName: 'float' };
+                    return { typeName: constants_1.TypeName.FLOAT };
                 case decorator_1.DecoratorID.IS_DOUBLE:
                 case 'isdouble':
-                    return { typeName: 'double' };
+                    return { typeName: constants_1.TypeName.DOUBLE };
                 default:
-                    return { typeName: 'double' };
+                    return { typeName: constants_1.TypeName.DOUBLE };
             }
         }
         else if (resolvedType === 'string') {
             return {
-                typeName: 'string',
+                typeName: constants_1.TypeName.STRING,
             };
         }
         else if (resolvedType === 'boolean') {
             return {
-                typeName: 'boolean',
+                typeName: constants_1.TypeName.BOOLEAN,
             };
         }
         else if (resolvedType === 'void') {
             return {
-                typeName: 'void',
+                typeName: constants_1.TypeName.VOID,
             };
         }
         else {
@@ -517,19 +531,17 @@ class TypeNodeResolver {
     }
     getDateType(parentNode) {
         if (!parentNode) {
-            return { typeName: 'datetime' };
+            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: 'datetime' };
+            return { typeName: constants_1.TypeName.DATETIME };
         }
         switch (tags[0]) {
             case 'isDate':
-                return { typeName: 'date' };
-            case 'isDateTime':
-                return { typeName: 'datetime' };
+                return { typeName: constants_1.TypeName.DATE };
             default:
-                return { typeName: 'datetime' };
+                return { typeName: constants_1.TypeName.DATETIME };
         }
     }
     static getDesignatedModels(nodes, typeName) {
@@ -550,7 +562,7 @@ class TypeNodeResolver {
         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',
+            typeName: constants_1.TypeName.REF_ENUM,
             description: this.getNodeDescription(enumDeclaration),
             members: enums,
             memberNames: enumNames,
@@ -567,7 +579,7 @@ class TypeNodeResolver {
             type = node.expression;
         }
         else {
-            throw new error_1.ResolverError('Can\'t resolve Reference type.');
+            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;
@@ -631,7 +643,7 @@ class TypeNodeResolver {
             }
             else if (ts.isEnumMember(declaration)) {
                 referenceType = {
-                    typeName: 'refEnum',
+                    typeName: constants_1.TypeName.REF_ENUM,
                     refName: TypeNodeResolver.getRefTypeName(name, utilityType),
                     members: [this.current.typeChecker.getConstantValue(declaration)],
                     memberNames: [declaration.name.getText()],
@@ -665,13 +677,13 @@ class TypeNodeResolver {
         }
         const example = this.getNodeExample(declaration);
         return {
-            typeName: 'refAlias',
+            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: getPropertyValidators(declaration) || {},
+            validators: (0, utils_1.getDeclarationValidators)(declaration) || {},
             deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
             ...(example && { example }),
         };
@@ -699,7 +711,7 @@ class TypeNodeResolver {
             }
             return {
                 refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`,
-                typeName: 'refAlias',
+                typeName: constants_1.TypeName.REF_ALIAS,
                 description,
                 type: new TypeNodeResolver(nodeType, this.current).resolve(),
                 deprecated,
@@ -712,7 +724,7 @@ class TypeNodeResolver {
         const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
         const referenceType = {
             additionalProperties,
-            typeName: 'refObject',
+            typeName: constants_1.TypeName.REF_OBJECT,
             description,
             properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions),
             refName: TypeNodeResolver.getRefTypeName(name, utilityType),
@@ -769,7 +781,7 @@ class TypeNodeResolver {
     }
     createCircularDependencyResolver(refName) {
         const referenceType = {
-            typeName: 'refObject',
+            typeName: constants_1.TypeName.REF_OBJECT,
             refName,
         };
         this.current.registerDependencyResolver((referenceTypes) => {
@@ -878,11 +890,12 @@ class TypeNodeResolver {
             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: getPropertyValidators(propertySignature) || {},
+            validators: (0, utils_1.getDeclarationValidators)(propertySignature) || {},
         };
         return property;
     }
@@ -917,11 +930,12 @@ class TypeNodeResolver {
             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: getPropertyValidators(propertyDeclaration) || {},
+            validators: (0, utils_1.getDeclarationValidators)(propertyDeclaration) || {},
         };
         return property;
     }
@@ -989,27 +1003,21 @@ class TypeNodeResolver {
                 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') {
+                    if ((0, type_1.isRefAliasType)(referenceType)) {
                         let type = referenceType;
-                        while (type.typeName === 'refAlias') {
+                        while ((0, type_1.isRefAliasType)(type)) {
                             type = type.type;
                         }
-                        if (type.typeName === 'refObject') {
+                        if (type.typeName === constants_1.TypeName.REF_OBJECT) {
                             properties = [...properties, ...type.properties];
                         }
-                        else if (type.typeName === 'nestedObjectLiteral') {
+                        else if (type.typeName === constants_1.TypeName.NESTED_OBJECT_LITERAL) {
                             properties = [...properties, ...type.properties];
                         }
                     }
-                    else if (referenceType.typeName === 'refObject') {
+                    if ((0, type_1.isRefObjectType)(referenceType)) {
                         referenceType.properties.forEach((property) => properties.push(property));
                     }
-                    else {
-                        // todo: should never assert
-                    }
                 }
                 // reset subContext
                 this.context = resetCtx;
@@ -1087,6 +1095,9 @@ class TypeNodeResolver {
         }
         return undefined;
     }
+    getNodeExtensions(node) {
+        return (0, extension_1.getNodeExtensions)(node, this.current.decoratorResolver);
+    }
 }
 exports.TypeNodeResolver = TypeNodeResolver;
 //# sourceMappingURL=module.js.map