@dipscope/type-manager 7.2.1 → 8.0.1

package/dist/es5/type-metadata.js

@@ -1,339 +1,620 @@
-import { __extends, __read, __values } from "tslib";
-import { first, isEmpty, isFunction, isNil, isUndefined } from 'lodash';
-import { CustomContext } from './custom-context';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { DEFAULT_VALUE_RESOLVER } from './constants/default-value-resolver';
+import { EMPTY_ARRAY } from './constants/empty-array';
+import { EMPTY_MAP } from './constants/empty-map';
+import { NULL_VALUE_RESOLVER } from './constants/null-value-resolver';
 import { getOwnReflectMetadata } from './functions/get-own-reflect-metadata';
 import { nameOf } from './functions/name-of';
 import { InjectMetadata } from './inject-metadata';
 import { Metadata } from './metadata';
 import { PropertyMetadata } from './property-metadata';
-import { typeExtensionMetadataCtorSetKey } from './type-extension-metadata-ctor-set-key';
+import { TYPE_EXTENSION_METADATA_CTOR_SET_KEY } from './type-extension-metadata-ctor-set-key';
+import { ResolvedTypeState } from './type-states/resolved-type-state';
+import { UnresolvedTypeState } from './type-states/unresolved-type-state';
 var TypeMetadata = (function (_super) {
     __extends(TypeMetadata, _super);
-    function TypeMetadata(typeManager, typeFn, typeOptions, parentTypeMetadatas) {
-        var _this = _super.call(this, typeManager) || this;
-        _this.childrenTypeMetadataMap = new Map();
-        _this.discriminantMap = new Map();
-        _this.propertyMetadataMap = new Map();
-        _this.injectMetadataMap = new Map();
+    function TypeMetadata(typeManager, typeFnMap, typeMetadataSet, typeFn, typeOptions, parentTypeMetadata) {
+        var _this = _super.call(this, typeManager, typeFnMap) || this;
         _this.typeName = nameOf(typeFn);
         _this.typeFn = typeFn;
+        _this.parentTypeMetadata = parentTypeMetadata;
         _this.typeOptionsBase = typeManager.typeOptionsBase;
         _this.typeOptions = _this.constructTypeOptions(typeOptions);
-        _this.typeInternals = _this.constructTypeInternals();
-        _this.parentTypeMetadatas = parentTypeMetadatas;
-        _this.deriveParentTypeMetadataProperties();
-        _this.hasDiscriminant(_this.discriminant);
+        _this.typeMetadataSet = typeMetadataSet;
+        _this.currentTypeFnMap = typeFnMap;
+        _this.currentChildTypeMetadataMap = new Map();
+        _this.currentPropertyMetadataMap = new Map();
+        _this.currentInjectMetadataMap = new Map();
+        _this.currentTypeState = new UnresolvedTypeState(_this);
+        _this.extendParentTypeMetadata();
         _this.configure(typeOptions);
         return _this;
     }
-    Object.defineProperty(TypeMetadata.prototype, "parentTypeMetadata", {
+    Object.defineProperty(TypeMetadata.prototype, "typeState", {
         get: function () {
-            return first(this.parentTypeMetadatas);
+            return this.currentTypeState;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "alias", {
+    Object.defineProperty(TypeMetadata.prototype, "injectMetadataMap", {
         get: function () {
-            return this.typeOptions.alias;
+            return this.currentTypeState.injectMetadataMap;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "customOptions", {
+    Object.defineProperty(TypeMetadata.prototype, "propertyMetadataMap", {
         get: function () {
-            return this.typeOptions.customOptions;
+            return this.currentTypeState.propertyMetadataMap;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "customContext", {
+    Object.defineProperty(TypeMetadata.prototype, "alias", {
         get: function () {
-            var customContext = this.typeInternals.customContext;
-            if (isNil(customContext)) {
-                this.typeOptions.customOptions = new Array();
-                this.typeInternals.customContext = new CustomContext(this.typeOptions.customOptions);
-                customContext = this.typeInternals.customContext;
-            }
-            return customContext;
+            return this.currentTypeState.alias;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeMetadata.prototype, "customValueMap", {
+        get: function () {
+            return this.currentTypeState.customValueMap;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "serializedNullValue", {
         get: function () {
-            if (this.preserveNull) {
-                return null;
-            }
-            return this.serializedDefaultValue;
+            return this.currentTypeState.serializedNullValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "serializedDefaultValue", {
         get: function () {
-            var _a;
-            if (this.useDefaultValue) {
-                var serializedDefaultValue = (_a = this.typeOptions.defaultValue) !== null && _a !== void 0 ? _a : this.typeOptions.serializedDefaultValue;
-                var defaultValue = isFunction(serializedDefaultValue)
-                    ? serializedDefaultValue()
-                    : serializedDefaultValue;
-                return defaultValue;
-            }
-            return undefined;
+            return this.currentTypeState.serializedDefaultValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "deserializedNullValue", {
         get: function () {
-            if (this.preserveNull) {
-                return null;
-            }
-            return this.deserializedDefaultValue;
+            return this.currentTypeState.deserializedNullValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "deserializedDefaultValue", {
         get: function () {
-            var _a;
-            if (this.useDefaultValue) {
-                var deserializedDefaultValue = (_a = this.typeOptions.defaultValue) !== null && _a !== void 0 ? _a : this.typeOptions.deserializedDefaultValue;
-                var defaultValue = isFunction(deserializedDefaultValue)
-                    ? deserializedDefaultValue()
-                    : deserializedDefaultValue;
-                return defaultValue;
-            }
-            return undefined;
+            return this.currentTypeState.deserializedDefaultValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "discriminant", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.discriminant) !== null && _a !== void 0 ? _a : this.typeName;
+            return this.currentTypeState.discriminant;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "discriminator", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.discriminator) !== null && _a !== void 0 ? _a : this.typeOptionsBase.discriminator;
+            return this.currentTypeState.discriminator;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "factory", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.factory) !== null && _a !== void 0 ? _a : this.typeOptionsBase.factory;
+            return this.currentTypeState.factory;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "injectable", {
         get: function () {
-            return this.typeOptions.injectable;
+            return this.currentTypeState.injectable;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "injector", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.injector) !== null && _a !== void 0 ? _a : this.typeOptionsBase.injector;
+            return this.currentTypeState.injector;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "log", {
+    Object.defineProperty(TypeMetadata.prototype, "logger", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.log) !== null && _a !== void 0 ? _a : this.typeOptionsBase.log;
+            return this.currentTypeState.logger;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "namingConvention", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.namingConvention) !== null && _a !== void 0 ? _a : this.typeOptionsBase.namingConvention;
+            return this.currentTypeState.namingConvention;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "polymorphic", {
         get: function () {
-            return this.discriminantMap.size > 1;
+            return this.currentTypeState.polymorphic;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "preserveDiscriminator", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.preserveDiscriminator) !== null && _a !== void 0 ? _a : this.typeOptionsBase.preserveDiscriminator;
+            return this.currentTypeState.preserveDiscriminator;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "referenceHandler", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.referenceHandler) !== null && _a !== void 0 ? _a : this.typeOptionsBase.referenceHandler;
+            return this.currentTypeState.referenceHandler;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "serializer", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.serializer) !== null && _a !== void 0 ? _a : this.typeOptionsBase.serializer;
+            return this.currentTypeState.serializer;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "preserveNull", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.preserveNull) !== null && _a !== void 0 ? _a : this.typeOptionsBase.preserveNull;
+            return this.currentTypeState.preserveNull;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "useDefaultValue", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.useDefaultValue) !== null && _a !== void 0 ? _a : this.typeOptionsBase.useDefaultValue;
+            return this.currentTypeState.useDefaultValue;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "useImplicitConversion", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.useImplicitConversion) !== null && _a !== void 0 ? _a : this.typeOptionsBase.useImplicitConversion;
+            return this.currentTypeState.useImplicitConversion;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "propertySorter", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.propertySorter) !== null && _a !== void 0 ? _a : this.typeOptionsBase.propertySorter;
+            return this.currentTypeState.propertySorter;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "sortedPropertyMetadatas", {
         get: function () {
-            var propertySorter = this.propertySorter;
-            var propertyMetadatas = this.propertyMetadataMap.values();
-            if (isNil(propertySorter)) {
-                return propertyMetadatas;
-            }
-            var sortedPropertyMetadatas = Array.from(propertyMetadatas).sort(propertySorter.sort);
-            return sortedPropertyMetadatas[Symbol.iterator]();
+            return this.currentTypeState.sortedPropertyMetadatas;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "injectSorter", {
         get: function () {
-            var _a;
-            return (_a = this.typeOptions.injectSorter) !== null && _a !== void 0 ? _a : this.typeOptionsBase.injectSorter;
+            return this.currentTypeState.injectSorter;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(TypeMetadata.prototype, "sortedInjectMetadatas", {
         get: function () {
-            var injectSorter = this.injectSorter;
-            var injectMetadatas = this.injectMetadataMap.values();
-            if (isNil(injectSorter)) {
-                return injectMetadatas;
-            }
-            var sortedInjectMetadatas = Array.from(injectMetadatas).sort(injectSorter.sort);
-            return sortedInjectMetadatas[Symbol.iterator]();
+            return this.currentTypeState.sortedInjectMetadatas;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "propertyOptionsMap", {
+    Object.defineProperty(TypeMetadata.prototype, "parentTypeArguments", {
         get: function () {
-            var propertyOptionsMap = this.typeOptions.propertyOptionsMap;
-            if (isNil(propertyOptionsMap)) {
-                propertyOptionsMap = new Map();
-                this.typeOptions.propertyOptionsMap = propertyOptionsMap;
-            }
-            return propertyOptionsMap;
+            return this.currentTypeState.parentTypeArguments;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "injectOptionsMap", {
+    Object.defineProperty(TypeMetadata.prototype, "propertyOptionsMap", {
         get: function () {
-            var injectOptionsMap = this.typeOptions.injectOptionsMap;
-            if (isNil(injectOptionsMap)) {
-                injectOptionsMap = new Map();
-                this.typeOptions.injectOptionsMap = injectOptionsMap;
-            }
-            return injectOptionsMap;
+            return this.currentTypeState.propertyOptionsMap;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TypeMetadata.prototype, "parentTypeFns", {
+    Object.defineProperty(TypeMetadata.prototype, "injectOptionsMap", {
         get: function () {
-            return this.typeOptions.parentTypeFns;
+            return this.currentTypeState.injectOptionsMap;
         },
         enumerable: false,
         configurable: true
     });
     TypeMetadata.prototype.constructTypeOptions = function (typeOptions) {
+        if (typeOptions.customValueMap === undefined) {
+            typeOptions.customValueMap = new Map();
+        }
+        if (typeOptions.propertyOptionsMap === undefined) {
+            typeOptions.propertyOptionsMap = new Map();
+        }
+        if (typeOptions.injectOptionsMap === undefined) {
+            typeOptions.injectOptionsMap = new Map();
+        }
         return typeOptions;
     };
-    TypeMetadata.prototype.constructTypeInternals = function () {
-        var customOptions = this.typeOptions.customOptions;
-        var customContext = isNil(customOptions) ? undefined : new CustomContext(customOptions);
-        var typeInternals = { customContext: customContext };
-        return typeInternals;
+    TypeMetadata.prototype.configureTypeExtensionMetadata = function (typeExtensionMetadataCtor, typeExtensionOptions) {
+        var typeExtensionMetadataCtorSet = this.extractTypeExtensionMetadataCtorSet();
+        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
+            typeExtensionMetadataCtorSet.add(typeExtensionMetadataCtor);
+        }
+        var initialTypeExtensionOptions = typeExtensionOptions !== null && typeExtensionOptions !== void 0 ? typeExtensionOptions : {};
+        var typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
+        return typeExtensionMetadata;
     };
-    TypeMetadata.prototype.deriveParentTypeMetadataProperties = function () {
-        var e_1, _a, e_2, _b;
-        if (isEmpty(this.parentTypeMetadatas)) {
-            return this;
+    TypeMetadata.prototype.extractTypeExtensionMetadata = function (typeExtensionMetadataCtor) {
+        var typeExtensionMetadataCtorSet = this.extractTypeExtensionMetadataCtorSet();
+        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
+            return undefined;
         }
+        var initialTypeExtensionOptions = {};
+        var typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
+        return typeExtensionMetadata;
+    };
+    TypeMetadata.prototype.extractTypeExtensionMetadataCtorSet = function () {
+        var customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
+        }
+        var typeExtensionMetadataCtorSet = customValueMap.get(TYPE_EXTENSION_METADATA_CTOR_SET_KEY);
+        if (typeExtensionMetadataCtorSet === undefined) {
+            typeExtensionMetadataCtorSet = new Set();
+            customValueMap.set(TYPE_EXTENSION_METADATA_CTOR_SET_KEY, typeExtensionMetadataCtorSet);
+        }
+        return typeExtensionMetadataCtorSet;
+    };
+    TypeMetadata.prototype.resolveTypeState = function () {
+        var typeOptionsBase = this.typeOptionsBase;
+        var typeOptions = this.typeOptions;
+        var typeName = this.typeName;
+        var alias = typeOptions.alias;
+        var customValueMap = this.resolveCustomValueMap();
+        var preserveNull = typeOptions.preserveNull === undefined
+            ? typeOptionsBase.preserveNull
+            : typeOptions.preserveNull;
+        var useDefaultValue = typeOptions.useDefaultValue === undefined
+            ? typeOptionsBase.useDefaultValue
+            : typeOptions.useDefaultValue;
+        var useImplicitConversion = typeOptions.useImplicitConversion === undefined
+            ? typeOptionsBase.useImplicitConversion
+            : typeOptions.useImplicitConversion;
+        var serializedDefaultValue = typeOptions.defaultValue === undefined
+            ? typeOptions.serializedDefaultValue
+            : typeOptions.defaultValue;
+        var serializedDefaultValueResolver = useDefaultValue
+            ? (typeof serializedDefaultValue === 'function' ? serializedDefaultValue : function () { return serializedDefaultValue; })
+            : DEFAULT_VALUE_RESOLVER;
+        var serializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : serializedDefaultValueResolver;
+        var deserializedDefaultValue = typeOptions.defaultValue === undefined
+            ? typeOptions.deserializedDefaultValue
+            : typeOptions.defaultValue;
+        var deserializedDefaultValueResolver = useDefaultValue
+            ? (typeof deserializedDefaultValue === 'function' ? deserializedDefaultValue : function () { return deserializedDefaultValue; })
+            : DEFAULT_VALUE_RESOLVER;
+        var deserializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : deserializedDefaultValueResolver;
+        var discriminant = typeOptions.discriminant === undefined
+            ? typeName
+            : typeOptions.discriminant;
+        var discriminator = typeOptions.discriminator === undefined
+            ? typeOptionsBase.discriminator
+            : typeOptions.discriminator;
+        var factory = typeOptions.factory === undefined
+            ? typeOptionsBase.factory
+            : typeOptions.factory;
+        var injectable = typeOptions.injectable === true;
+        var injector = typeOptions.injector === undefined
+            ? typeOptionsBase.injector
+            : typeOptions.injector;
+        var logger = typeOptions.logger === undefined
+            ? typeOptionsBase.logger
+            : typeOptions.logger;
+        var namingConvention = typeOptions.namingConvention === undefined
+            ? typeOptionsBase.namingConvention
+            : typeOptions.namingConvention;
+        var parentTypeArguments = typeOptions.parentTypeArguments === undefined
+            ? EMPTY_ARRAY
+            : typeOptions.parentTypeArguments;
+        var ownParentTypeMetadatas = this.resolveOwnParentTypeMetadatas(parentTypeArguments);
+        var ownChildTypeMetadatas = this.resolveOwnChildTypeMetadatas();
+        var parentTypeMetadataSet = this.resolveParentTypeMetadataSet(this);
+        var parentTypeMetadatas = Array.from(parentTypeMetadataSet);
+        var childTypeMetadataSet = this.resolveChildTypeMetadataSet(this);
+        var childTypeMetadatas = Array.from(childTypeMetadataSet);
+        var typeMetadataMap = new Map();
+        var polymorphic = childTypeMetadatas.length > 1;
+        for (var i = 0; i < childTypeMetadatas.length; i++) {
+            var childTypeMetadata = childTypeMetadatas[i];
+            typeMetadataMap.set(childTypeMetadata.typeFn, childTypeMetadata);
+        }
+        var preserveDiscriminator = typeOptions.preserveDiscriminator === undefined
+            ? typeOptionsBase.preserveDiscriminator
+            : typeOptions.preserveDiscriminator;
+        var referenceHandler = typeOptions.referenceHandler === undefined
+            ? typeOptionsBase.referenceHandler
+            : typeOptions.referenceHandler;
+        var serializer = typeOptions.serializer === undefined
+            ? typeOptionsBase.serializer
+            : typeOptions.serializer;
+        var propertySorter = typeOptions.propertySorter === undefined
+            ? typeOptionsBase.propertySorter
+            : typeOptions.propertySorter;
+        var ownPropertyMetadataMap = this.currentPropertyMetadataMap;
+        var propertyMetadataMap = this.resolvePropertyMetadataMap(parentTypeMetadatas);
+        var sortedPropertyMetadatas = propertySorter === undefined
+            ? Array.from(propertyMetadataMap.values())
+            : Array.from(propertyMetadataMap.values()).sort(propertySorter.sort);
+        var injectMetadataMap = this.currentInjectMetadataMap;
+        var injectSorter = typeOptions.injectSorter === undefined
+            ? typeOptionsBase.injectSorter
+            : typeOptions.injectSorter;
+        var sortedInjectMetadatas = injectSorter === undefined
+            ? Array.from(injectMetadataMap.values())
+            : Array.from(injectMetadataMap.values()).sort(injectSorter.sort);
+        var propertyOptionsMap = typeOptions.propertyOptionsMap === undefined
+            ? EMPTY_MAP
+            : typeOptions.propertyOptionsMap;
+        var injectOptionsMap = typeOptions.injectOptionsMap === undefined
+            ? EMPTY_MAP
+            : typeOptions.injectOptionsMap;
+        var resolvedTypeState = new ResolvedTypeState(this, alias, customValueMap, serializedNullValueResolver, serializedDefaultValue, serializedDefaultValueResolver, deserializedNullValueResolver, deserializedDefaultValue, deserializedDefaultValueResolver, discriminant, discriminator, factory, injectable, injector, logger, namingConvention, polymorphic, typeMetadataMap, preserveDiscriminator, referenceHandler, serializer, preserveNull, useDefaultValue, useImplicitConversion, propertySorter, sortedPropertyMetadatas, injectSorter, sortedInjectMetadatas, parentTypeArguments, parentTypeMetadatas, ownParentTypeMetadatas, childTypeMetadatas, ownChildTypeMetadatas, propertyOptionsMap, propertyMetadataMap, ownPropertyMetadataMap, injectOptionsMap, injectMetadataMap);
+        this.currentTypeState = resolvedTypeState;
+        return resolvedTypeState;
+    };
+    TypeMetadata.prototype.unresolveTypeState = function () {
+        var unresolvedTypeState = new UnresolvedTypeState(this);
+        this.currentTypeState = unresolvedTypeState;
+        return unresolvedTypeState;
+    };
+    TypeMetadata.prototype.resolveCustomValueMap = function () {
+        var e_1, _a;
+        var typeOptionsBase = this.typeOptionsBase;
+        var typeOptions = this.typeOptions;
+        var customValueMap = new Map();
+        if (typeOptions.customValueMap === undefined) {
+            return customValueMap;
+        }
+        var baseCustomValueMap = typeOptionsBase.customValueMap === undefined
+            ? EMPTY_MAP
+            : typeOptionsBase.customValueMap;
         try {
-            for (var _c = __values(this.parentTypeMetadatas), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var parentTypeMetadata = _d.value;
-                try {
-                    for (var _e = (e_2 = void 0, __values(parentTypeMetadata.propertyMetadataMap)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var _g = __read(_f.value, 2), propertyName = _g[0], propertyMetadata = _g[1];
-                        if (!this.propertyMetadataMap.has(propertyName)) {
-                            this.propertyMetadataMap.set(propertyName, propertyMetadata);
-                        }
-                    }
+            for (var _b = __values(typeOptions.customValueMap), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), customKey = _d[0], customValue = _d[1];
+                if (customValue === undefined) {
+                    customValueMap.set(customKey, baseCustomValueMap.get(customKey));
+                    continue;
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                customValueMap.set(customKey, customValue);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return customValueMap;
+    };
+    TypeMetadata.prototype.resolveOwnParentTypeMetadatas = function (parentTypeArguments) {
+        var ownParentTypeMetadatas = new Array();
+        var parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+        for (var i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            ownParentTypeMetadatas.push(parentTypeMetadatas[i]);
+        }
+        if (this.parentTypeMetadata !== undefined) {
+            ownParentTypeMetadatas.push(this.parentTypeMetadata);
+        }
+        return ownParentTypeMetadatas;
+    };
+    TypeMetadata.prototype.resolveOwnChildTypeMetadatas = function () {
+        var e_2, _a, e_3, _b;
+        var ownChildTypeMetadatas = new Array();
+        try {
+            for (var _c = __values(this.currentChildTypeMetadataMap.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var childTypeMetadata = _d.value;
+                ownChildTypeMetadatas.push(childTypeMetadata);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var _e = __values(this.typeMetadataSet), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var setTypeMetadata = _f.value;
+                var typeOptions = setTypeMetadata.typeOptions;
+                var parentTypeArguments = typeOptions.parentTypeArguments === undefined
+                    ? EMPTY_ARRAY
+                    : typeOptions.parentTypeArguments;
+                var parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+                for (var i = 0; i < parentTypeMetadatas.length; i++) {
+                    if (parentTypeMetadatas[i] === this) {
+                        ownChildTypeMetadatas.push(setTypeMetadata);
+                        break;
                     }
-                    finally { if (e_2) throw e_2.error; }
                 }
-                parentTypeMetadata.childrenTypeMetadataMap.set(this.typeFn, this);
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return ownChildTypeMetadatas;
+    };
+    TypeMetadata.prototype.resolveParentTypeMetadataSet = function (typeMetadata, parentTypeMetadataSet) {
+        if (parentTypeMetadataSet === void 0) { parentTypeMetadataSet = new Set(); }
+        if (parentTypeMetadataSet.has(typeMetadata)) {
+            return parentTypeMetadataSet;
+        }
+        parentTypeMetadataSet.add(typeMetadata);
+        var typeOptions = typeMetadata.typeOptions;
+        var parentTypeArguments = typeOptions.parentTypeArguments === undefined
+            ? EMPTY_ARRAY
+            : typeOptions.parentTypeArguments;
+        var parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+        for (var i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            this.resolveParentTypeMetadataSet(parentTypeMetadatas[i], parentTypeMetadataSet);
+        }
+        if (typeMetadata.parentTypeMetadata !== undefined) {
+            this.resolveParentTypeMetadataSet(typeMetadata.parentTypeMetadata, parentTypeMetadataSet);
+        }
+        return parentTypeMetadataSet;
+    };
+    TypeMetadata.prototype.resolveChildTypeMetadataSet = function (typeMetadata, childTypeMetadataSet) {
+        var e_4, _a, e_5, _b;
+        if (childTypeMetadataSet === void 0) { childTypeMetadataSet = new Set(); }
+        if (childTypeMetadataSet.has(typeMetadata)) {
+            return childTypeMetadataSet;
+        }
+        childTypeMetadataSet.add(typeMetadata);
+        try {
+            for (var _c = __values(typeMetadata.currentChildTypeMetadataMap.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var childTypeMetadata = _d.value;
+                this.resolveChildTypeMetadataSet(childTypeMetadata, childTypeMetadataSet);
+                childTypeMetadata.unresolveTypeState();
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_4) throw e_4.error; }
+        }
+        try {
+            for (var _e = __values(this.typeMetadataSet), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var setTypeMetadata = _f.value;
+                var typeOptions = setTypeMetadata.typeOptions;
+                var parentTypeArguments = typeOptions.parentTypeArguments === undefined
+                    ? EMPTY_ARRAY
+                    : typeOptions.parentTypeArguments;
+                var parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+                for (var i = 0; i < parentTypeMetadatas.length; i++) {
+                    if (parentTypeMetadatas[i] === typeMetadata) {
+                        this.resolveChildTypeMetadataSet(setTypeMetadata, childTypeMetadataSet);
+                        setTypeMetadata.unresolveTypeState();
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return childTypeMetadataSet;
+    };
+    TypeMetadata.prototype.resolvePropertyMetadataMap = function (parentTypeMetadatas) {
+        var e_6, _a, e_7, _b;
+        var propertyMetadataMap = new Map();
+        for (var i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            try {
+                for (var _c = (e_6 = void 0, __values(parentTypeMetadatas[i].currentPropertyMetadataMap)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), propertyName = _e[0], propertyMetadata = _e[1];
+                    propertyMetadataMap.set(propertyName, propertyMetadata);
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+        try {
+            for (var _f = __values(this.currentPropertyMetadataMap.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var propertyMetadata = _g.value;
+                propertyMetadata.unresolvePropertyState();
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return propertyMetadataMap;
+    };
+    TypeMetadata.prototype.extendParentTypeMetadata = function () {
+        var parentTypeMetadata = this.parentTypeMetadata;
+        if (parentTypeMetadata !== undefined) {
+            parentTypeMetadata.currentChildTypeMetadataMap.set(this.typeFn, this);
         }
         return this;
     };
@@ -344,8 +625,8 @@ var TypeMetadata = (function (_super) {
         }
         var injectTypeFns = ((_a = getOwnReflectMetadata('design:paramtypes', this.typeFn)) !== null && _a !== void 0 ? _a : new Array());
         for (var injectIndex = 0; injectIndex < injectTypeFns.length; injectIndex++) {
-            if (!this.injectMetadataMap.has(injectIndex)) {
-                this.configureInjectMetadata(injectIndex, { typeFn: injectTypeFns[injectIndex] });
+            if (!this.currentInjectMetadataMap.has(injectIndex)) {
+                this.configureInjectMetadata(injectIndex, { typeArgument: injectTypeFns[injectIndex] });
             }
         }
         return this;
@@ -353,311 +634,354 @@ var TypeMetadata = (function (_super) {
     TypeMetadata.prototype.hasAlias = function (alias) {
         this.releaseAlias();
         this.typeOptions.alias = alias;
-        if (!isNil(alias)) {
-            this.typeFnMap.set(alias, this.typeFn);
+        if (alias !== undefined) {
+            this.currentTypeFnMap.set(alias, this.typeFn);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.releaseAlias = function () {
-        var alias = this.alias;
-        if (!isNil(alias) && this.typeFnMap.has(alias)) {
-            this.typeFnMap.delete(alias);
+        var alias = this.typeOptions.alias;
+        if (alias !== undefined && this.currentTypeFnMap.has(alias)) {
+            this.currentTypeFnMap.delete(alias);
+        }
+        return this;
+    };
+    TypeMetadata.prototype.hasCustomValueMap = function (customValueMap) {
+        var e_8, _a;
+        var currentCustomValueMap = this.typeOptions.customValueMap;
+        if (currentCustomValueMap === undefined) {
+            currentCustomValueMap = new Map();
+            this.typeOptions.customValueMap = currentCustomValueMap;
+        }
+        if (customValueMap !== undefined) {
+            if (currentCustomValueMap !== customValueMap) {
+                currentCustomValueMap.clear();
+            }
+            try {
+                for (var customValueMap_1 = __values(customValueMap), customValueMap_1_1 = customValueMap_1.next(); !customValueMap_1_1.done; customValueMap_1_1 = customValueMap_1.next()) {
+                    var _b = __read(customValueMap_1_1.value, 2), customKey = _b[0], customValue = _b[1];
+                    currentCustomValueMap.set(customKey, customValue);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (customValueMap_1_1 && !customValueMap_1_1.done && (_a = customValueMap_1.return)) _a.call(customValueMap_1);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
-    TypeMetadata.prototype.hasCustomOption = function (customKey, customValue) {
-        this.customContext.set(customKey, customValue);
+    TypeMetadata.prototype.hasCustomValue = function (customKey, customValue) {
+        var customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
+        }
+        customValueMap.set(customKey, customValue);
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
-    TypeMetadata.prototype.extractCustomOption = function (customKey) {
-        return this.customContext.get(customKey);
+    TypeMetadata.prototype.extractCustomValue = function (customKey) {
+        var customValue = this.typeState.customValueMap.get(customKey);
+        if (customValue === undefined && customKey.customValueResolver !== undefined) {
+            customValue = customKey.customValueResolver();
+        }
+        return customValue;
     };
     TypeMetadata.prototype.hasCustomOptions = function (customOptions) {
-        if (!isNil(customOptions)) {
-            this.customContext.configure(customOptions);
+        var customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
         }
+        for (var i = 0; i < customOptions.length; i++) {
+            customValueMap.set(customOptions[i][0], customOptions[i][1]);
+        }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasDefaultValue = function (defaultValue) {
         this.typeOptions.defaultValue = defaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasSerializedDefaultValue = function (serializedDefaultValue) {
         this.typeOptions.serializedDefaultValue = serializedDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasDeserializedDefaultValue = function (deserializedDefaultValue) {
         this.typeOptions.deserializedDefaultValue = deserializedDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasDiscriminator = function (discriminator) {
         this.typeOptions.discriminator = discriminator;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasDiscriminant = function (discriminant) {
         this.typeOptions.discriminant = discriminant;
-        if (!isNil(discriminant)) {
-            this.provideDiscriminant(this.typeFn, discriminant);
-        }
-        return this;
-    };
-    TypeMetadata.prototype.provideDiscriminant = function (typeFn, discriminant) {
-        var e_3, _a;
-        this.discriminantMap.set(typeFn, discriminant);
-        if (!isEmpty(this.parentTypeMetadatas)) {
-            try {
-                for (var _b = __values(this.parentTypeMetadatas), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var parentTypeMetadata = _c.value;
-                    parentTypeMetadata.provideDiscriminant(typeFn, discriminant);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-        }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasFactory = function (factory) {
         this.typeOptions.factory = factory;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.isInjectable = function (injectable) {
         if (injectable === void 0) { injectable = true; }
         this.typeOptions.injectable = injectable;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasInjector = function (injector) {
         this.typeOptions.injector = injector;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
-    TypeMetadata.prototype.hasLog = function (log) {
-        this.typeOptions.log = log;
+    TypeMetadata.prototype.hasLogger = function (logger) {
+        this.typeOptions.logger = logger;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasNamingConvention = function (namingConvention) {
         this.typeOptions.namingConvention = namingConvention;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.shouldPreserveDiscriminator = function (preserveDiscriminator) {
         if (preserveDiscriminator === void 0) { preserveDiscriminator = true; }
         this.typeOptions.preserveDiscriminator = preserveDiscriminator;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasReferenceHandler = function (referenceHandler) {
         this.typeOptions.referenceHandler = referenceHandler;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasSerializer = function (serializer) {
         this.typeOptions.serializer = serializer;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.shouldPreserveNull = function (preserveNull) {
         if (preserveNull === void 0) { preserveNull = true; }
         this.typeOptions.preserveNull = preserveNull;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.shouldUseDefaultValue = function (useDefaultValue) {
         if (useDefaultValue === void 0) { useDefaultValue = true; }
         this.typeOptions.useDefaultValue = useDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.shouldUseImplicitConversion = function (useImplicitConversion) {
         if (useImplicitConversion === void 0) { useImplicitConversion = true; }
         this.typeOptions.useImplicitConversion = useImplicitConversion;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasPropertySorter = function (propertySorter) {
         this.typeOptions.propertySorter = propertySorter;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.hasInjectSorter = function (injectSorter) {
         this.typeOptions.injectSorter = injectSorter;
+        this.currentTypeState = new UnresolvedTypeState(this);
+        return this;
+    };
+    TypeMetadata.prototype.hasParentTypeArguments = function (parentTypeArguments) {
+        this.typeOptions.parentTypeArguments = parentTypeArguments;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
     TypeMetadata.prototype.configurePropertyMetadata = function (propertyName, propertyOptions) {
-        var propertyMetadata = this.propertyMetadataMap.get(propertyName);
-        if (isNil(propertyMetadata)) {
-            propertyMetadata = new PropertyMetadata(this, propertyName, propertyOptions !== null && propertyOptions !== void 0 ? propertyOptions : {});
-            this.propertyMetadataMap.set(propertyName, propertyMetadata);
-            this.propertyOptionsMap.set(propertyName, propertyMetadata.propertyOptions);
+        var propertyOptionsMap = this.typeOptions.propertyOptionsMap;
+        if (propertyOptionsMap === undefined) {
+            propertyOptionsMap = new Map();
+            this.typeOptions.propertyOptionsMap = propertyOptionsMap;
+        }
+        var propertyMetadata = this.currentPropertyMetadataMap.get(propertyName);
+        if (propertyMetadata === undefined) {
+            propertyOptions = propertyOptions !== null && propertyOptions !== void 0 ? propertyOptions : {};
+            propertyMetadata = new PropertyMetadata(this.typeManager, this.currentTypeFnMap, this, propertyName, propertyOptions);
+            this.currentPropertyMetadataMap.set(propertyName, propertyMetadata);
+            propertyOptionsMap.set(propertyName, propertyOptions);
+            this.currentTypeState = new UnresolvedTypeState(this);
             return propertyMetadata;
         }
-        if (!isNil(propertyOptions)) {
+        if (propertyOptions !== undefined) {
             propertyMetadata.configure(propertyOptions);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return propertyMetadata;
     };
     TypeMetadata.prototype.configureInjectMetadata = function (injectIndex, injectOptions) {
-        var injectMetadata = this.injectMetadataMap.get(injectIndex);
-        if (isNil(injectMetadata)) {
-            injectMetadata = new InjectMetadata(this, injectIndex, injectOptions !== null && injectOptions !== void 0 ? injectOptions : {});
-            this.injectMetadataMap.set(injectIndex, injectMetadata);
-            this.injectOptionsMap.set(injectIndex, injectMetadata.injectOptions);
+        var injectOptionsMap = this.typeOptions.injectOptionsMap;
+        if (injectOptionsMap === undefined) {
+            injectOptionsMap = new Map();
+            this.typeOptions.injectOptionsMap = injectOptionsMap;
+        }
+        var injectMetadata = this.currentInjectMetadataMap.get(injectIndex);
+        if (injectMetadata === undefined) {
+            injectOptions = injectOptions !== null && injectOptions !== void 0 ? injectOptions : {};
+            injectMetadata = new InjectMetadata(this.typeManager, this.currentTypeFnMap, this, injectIndex, injectOptions);
+            this.currentInjectMetadataMap.set(injectIndex, injectMetadata);
+            injectOptionsMap.set(injectIndex, injectOptions);
+            this.currentTypeState = new UnresolvedTypeState(this);
             return injectMetadata;
         }
-        if (!isNil(injectOptions)) {
+        if (injectOptions !== undefined) {
             injectMetadata.configure(injectOptions);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return injectMetadata;
     };
     TypeMetadata.prototype.hasPropertyMetadataMap = function (propertyOptionsMap) {
-        var e_4, _a;
+        var e_9, _a;
+        var currentPropertyOptionsMap = this.clearPropertyOptionsMap(propertyOptionsMap);
         try {
             for (var propertyOptionsMap_1 = __values(propertyOptionsMap), propertyOptionsMap_1_1 = propertyOptionsMap_1.next(); !propertyOptionsMap_1_1.done; propertyOptionsMap_1_1 = propertyOptionsMap_1.next()) {
                 var _b = __read(propertyOptionsMap_1_1.value, 2), propertyName = _b[0], propertyOptions = _b[1];
-                this.configurePropertyMetadata(propertyName, propertyOptions);
+                var propertyMetadata = new PropertyMetadata(this.typeManager, this.currentTypeFnMap, this, propertyName, propertyOptions);
+                this.currentPropertyMetadataMap.set(propertyName, propertyMetadata);
+                currentPropertyOptionsMap.set(propertyName, propertyOptions);
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
                 if (propertyOptionsMap_1_1 && !propertyOptionsMap_1_1.done && (_a = propertyOptionsMap_1.return)) _a.call(propertyOptionsMap_1);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_9) throw e_9.error; }
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
+    TypeMetadata.prototype.clearPropertyOptionsMap = function (propertyOptionsMap) {
+        var currentPropertyOptionsMap = this.typeOptions.propertyOptionsMap;
+        if (currentPropertyOptionsMap === undefined) {
+            currentPropertyOptionsMap = new Map();
+            this.typeOptions.propertyOptionsMap = currentPropertyOptionsMap;
+        }
+        if (currentPropertyOptionsMap !== propertyOptionsMap) {
+            currentPropertyOptionsMap.clear();
+            this.currentPropertyMetadataMap.clear();
+        }
+        return currentPropertyOptionsMap;
+    };
     TypeMetadata.prototype.hasInjectMetadataMap = function (injectOptionsMap) {
-        var e_5, _a;
+        var e_10, _a;
+        var currentInjectOptionsMap = this.clearInjectOptionsMap(injectOptionsMap);
         try {
             for (var injectOptionsMap_1 = __values(injectOptionsMap), injectOptionsMap_1_1 = injectOptionsMap_1.next(); !injectOptionsMap_1_1.done; injectOptionsMap_1_1 = injectOptionsMap_1.next()) {
                 var _b = __read(injectOptionsMap_1_1.value, 2), injectIndex = _b[0], injectOptions = _b[1];
-                this.configureInjectMetadata(injectIndex, injectOptions);
+                var injectMetadata = new InjectMetadata(this.typeManager, this.currentTypeFnMap, this, injectIndex, injectOptions);
+                this.currentInjectMetadataMap.set(injectIndex, injectMetadata);
+                currentInjectOptionsMap.set(injectIndex, injectOptions);
             }
         }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (injectOptionsMap_1_1 && !injectOptionsMap_1_1.done && (_a = injectOptionsMap_1.return)) _a.call(injectOptionsMap_1);
             }
-            finally { if (e_5) throw e_5.error; }
+            finally { if (e_10) throw e_10.error; }
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     };
-    TypeMetadata.prototype.configureTypeExtensionMetadata = function (typeExtensionMetadataCtor, typeExtensionOptions) {
-        var typeExtensionMetadataCtorSet = this.extractCustomOption(typeExtensionMetadataCtorSetKey);
-        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
-            typeExtensionMetadataCtorSet.add(typeExtensionMetadataCtor);
+    TypeMetadata.prototype.clearInjectOptionsMap = function (injectOptionsMap) {
+        var currentInjectOptionsMap = this.typeOptions.injectOptionsMap;
+        if (currentInjectOptionsMap === undefined) {
+            currentInjectOptionsMap = new Map();
+            this.typeOptions.injectOptionsMap = currentInjectOptionsMap;
         }
-        var initialTypeExtensionOptions = typeExtensionOptions !== null && typeExtensionOptions !== void 0 ? typeExtensionOptions : {};
-        var typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
-        return typeExtensionMetadata;
-    };
-    TypeMetadata.prototype.extractTypeExtensionMetadata = function (typeExtensionMetadataCtor) {
-        var typeExtensionMetadataCtorSet = this.extractCustomOption(typeExtensionMetadataCtorSetKey);
-        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
-            return undefined;
+        if (currentInjectOptionsMap !== injectOptionsMap) {
+            currentInjectOptionsMap.clear();
+            this.currentInjectMetadataMap.clear();
         }
-        var initialTypeExtensionOptions = {};
-        var typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
-        return typeExtensionMetadata;
-    };
-    TypeMetadata.prototype.hasParentTypeFns = function (parentTypeFns) {
-        var e_6, _a;
-        if (isNil(this.typeOptions.parentTypeFns)) {
-            this.typeOptions.parentTypeFns = new Array();
-        }
-        var _loop_1 = function (parentTypeFn) {
-            var parentTypeMetadata = this_1.typeManager.extractTypeMetadata(parentTypeFn);
-            if (!this_1.parentTypeMetadatas.some(function (ptm) { return ptm === parentTypeMetadata; })) {
-                this_1.parentTypeMetadatas.push(parentTypeMetadata);
-            }
-            if (!this_1.typeOptions.parentTypeFns.some(function (ptf) { return ptf === parentTypeFn; })) {
-                this_1.typeOptions.parentTypeFns.push(parentTypeFn);
-            }
-        };
-        var this_1 = this;
-        try {
-            for (var parentTypeFns_1 = __values(parentTypeFns), parentTypeFns_1_1 = parentTypeFns_1.next(); !parentTypeFns_1_1.done; parentTypeFns_1_1 = parentTypeFns_1.next()) {
-                var parentTypeFn = parentTypeFns_1_1.value;
-                _loop_1(parentTypeFn);
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (parentTypeFns_1_1 && !parentTypeFns_1_1.done && (_a = parentTypeFns_1.return)) _a.call(parentTypeFns_1);
-            }
-            finally { if (e_6) throw e_6.error; }
-        }
-        this.deriveParentTypeMetadataProperties();
-        this.hasDiscriminant(this.discriminant);
-        return this;
+        return currentInjectOptionsMap;
     };
     TypeMetadata.prototype.configure = function (typeOptions) {
-        if (!isUndefined(typeOptions.parentTypeFns)) {
-            this.hasParentTypeFns(typeOptions.parentTypeFns);
-        }
-        if (!isUndefined(typeOptions.alias)) {
+        if (typeOptions.alias !== undefined) {
             this.hasAlias(typeOptions.alias);
         }
-        if (!isUndefined(typeOptions.customOptions)) {
-            this.hasCustomOptions(typeOptions.customOptions);
+        if (typeOptions.customValueMap !== undefined) {
+            this.hasCustomValueMap(typeOptions.customValueMap);
         }
-        if (!isUndefined(typeOptions.defaultValue)) {
+        if (typeOptions.defaultValue !== undefined) {
             this.hasDefaultValue(typeOptions.defaultValue);
         }
-        if (!isUndefined(typeOptions.serializedDefaultValue)) {
+        if (typeOptions.serializedDefaultValue !== undefined) {
             this.hasSerializedDefaultValue(typeOptions.serializedDefaultValue);
         }
-        if (!isUndefined(typeOptions.deserializedDefaultValue)) {
+        if (typeOptions.deserializedDefaultValue !== undefined) {
             this.hasDeserializedDefaultValue(typeOptions.deserializedDefaultValue);
         }
-        if (!isUndefined(typeOptions.discriminator)) {
+        if (typeOptions.discriminator !== undefined) {
             this.hasDiscriminator(typeOptions.discriminator);
         }
-        if (!isUndefined(typeOptions.discriminant)) {
+        if (typeOptions.discriminant !== undefined) {
             this.hasDiscriminant(typeOptions.discriminant);
         }
-        if (!isUndefined(typeOptions.factory)) {
+        if (typeOptions.factory !== undefined) {
             this.hasFactory(typeOptions.factory);
         }
-        if (!isUndefined(typeOptions.injectable)) {
+        if (typeOptions.injectable !== undefined) {
             this.isInjectable(typeOptions.injectable);
         }
-        if (!isUndefined(typeOptions.injector)) {
+        if (typeOptions.injector !== undefined) {
             this.hasInjector(typeOptions.injector);
         }
-        if (!isUndefined(typeOptions.log)) {
-            this.hasLog(typeOptions.log);
+        if (typeOptions.logger !== undefined) {
+            this.hasLogger(typeOptions.logger);
         }
-        if (!isUndefined(typeOptions.namingConvention)) {
+        if (typeOptions.namingConvention !== undefined) {
             this.hasNamingConvention(typeOptions.namingConvention);
         }
-        if (!isUndefined(typeOptions.preserveDiscriminator)) {
+        if (typeOptions.preserveDiscriminator !== undefined) {
             this.shouldPreserveDiscriminator(typeOptions.preserveDiscriminator);
         }
-        if (!isUndefined(typeOptions.referenceHandler)) {
+        if (typeOptions.referenceHandler !== undefined) {
             this.hasReferenceHandler(typeOptions.referenceHandler);
         }
-        if (!isUndefined(typeOptions.serializer)) {
+        if (typeOptions.serializer !== undefined) {
             this.hasSerializer(typeOptions.serializer);
         }
-        if (!isUndefined(typeOptions.preserveNull)) {
+        if (typeOptions.preserveNull !== undefined) {
             this.shouldPreserveNull(typeOptions.preserveNull);
         }
-        if (!isUndefined(typeOptions.useDefaultValue)) {
+        if (typeOptions.useDefaultValue !== undefined) {
             this.shouldUseDefaultValue(typeOptions.useDefaultValue);
         }
-        if (!isUndefined(typeOptions.useImplicitConversion)) {
+        if (typeOptions.useImplicitConversion !== undefined) {
             this.shouldUseImplicitConversion(typeOptions.useImplicitConversion);
         }
-        if (!isUndefined(typeOptions.propertyOptionsMap)) {
+        if (typeOptions.propertyOptionsMap !== undefined) {
             this.hasPropertyMetadataMap(typeOptions.propertyOptionsMap);
         }
-        if (!isUndefined(typeOptions.injectOptionsMap)) {
+        if (typeOptions.injectOptionsMap !== undefined) {
             this.hasInjectMetadataMap(typeOptions.injectOptionsMap);
         }
-        if (!isUndefined(typeOptions.propertySorter)) {
+        if (typeOptions.propertySorter !== undefined) {
             this.hasPropertySorter(typeOptions.propertySorter);
         }
-        if (!isUndefined(typeOptions.injectSorter)) {
+        if (typeOptions.injectSorter !== undefined) {
             this.hasInjectSorter(typeOptions.injectSorter);
         }
+        if (typeOptions.parentTypeArguments !== undefined) {
+            this.hasParentTypeArguments(typeOptions.parentTypeArguments);
+        }
         return this;
     };
     return TypeMetadata;