@dipscope/type-manager 7.0.0-beta.0 → 7.0.1

package/dist/es5/type-manager.js

@@ -1,413 +1,413 @@
-import { __read, __values } from "tslib";
-import { assign, isArray, isNil, isUndefined } from 'lodash';
-import { Any } from './any';
-import { CustomContext } from './custom-context';
-import { TypeFactory } from './factories/type-factory';
-import { jsonParse } from './functions/json-parse';
-import { jsonStringify } from './functions/json-stringify';
-import { SingletonInjector } from './injectors/singleton-injector';
-import { Log } from './log';
-import { LogLevel } from './log-level';
-import { CircularReferenceHandler } from './reference-handlers/circular-reference-handler';
-import { SerializerContext } from './serializer-context';
-import { AnySerializer } from './serializers/any-serializer';
-import { ArrayBufferSerializer } from './serializers/array-buffer-serializer';
-import { ArraySerializer } from './serializers/array-serializer';
-import { BooleanSerializer } from './serializers/boolean-serializer';
-import { DataViewSerializer } from './serializers/data-view-serializer';
-import { DateSerializer } from './serializers/date-serializer';
-import { Float32ArraySerializer } from './serializers/float-32-array-serializer';
-import { Float64ArraySerializer } from './serializers/float-64-array-serializer';
-import { Int16ArraySerializer } from './serializers/int-16-array-serializer';
-import { Int32ArraySerializer } from './serializers/int-32-array-serializer';
-import { Int8ArraySerializer } from './serializers/int-8-array-serializer';
-import { MapSerializer } from './serializers/map-serializer';
-import { NumberSerializer } from './serializers/number-serializer';
-import { SetSerializer } from './serializers/set-serializer';
-import { StringSerializer } from './serializers/string-serializer';
-import { TypeSerializer } from './serializers/type-serializer';
-import { Uint16ArraySerializer } from './serializers/uint-16-array-serializer';
-import { Uint32ArraySerializer } from './serializers/uint-32-array-serializer';
-import { Uint8ArraySerializer } from './serializers/uint-8-array-serializer';
-import { Uint8ClampedArraySerializer } from './serializers/uint-8-clamped-array-serializer';
-import { UnknownSerializer } from './serializers/unknown-serializer';
-import { TypeMetadata } from './type-metadata';
-import { typeMetadataSymbol } from './type-metadata-symbol';
-import { Unknown } from './unknown';
-var TypeManager = (function () {
-    function TypeManager(typeManagerOptions) {
-        if (typeManagerOptions === void 0) { typeManagerOptions = {}; }
-        this.typeFnMap = new Map();
-        this.symbol = Symbol(typeMetadataSymbol.description);
-        this.typeManagerOptions = this.constructTypeManagerOptions(typeManagerOptions);
-        this.customContext = this.constructCustomContext();
-        this.configure(typeManagerOptions);
-        return;
-    }
-    Object.defineProperty(TypeManager, "typeFnMap", {
-        get: function () {
-            return this.staticTypeManager.typeFnMap;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager, "symbol", {
-        get: function () {
-            return this.staticTypeManager.symbol;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager, "typeManagerOptions", {
-        get: function () {
-            return this.staticTypeManager.typeManagerOptions;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager, "typeOptionsBase", {
-        get: function () {
-            return this.staticTypeManager.typeOptionsBase;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager.prototype, "typeOptionsBase", {
-        get: function () {
-            var typeOptionsBase = this.typeManagerOptions.typeOptionsBase;
-            if (isNil(typeOptionsBase)) {
-                typeOptionsBase = {};
-                this.typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
-            }
-            return typeOptionsBase;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager, "typeOptionsMap", {
-        get: function () {
-            return this.staticTypeManager.typeOptionsMap;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager.prototype, "typeOptionsMap", {
-        get: function () {
-            var typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
-            if (isNil(typeOptionsMap)) {
-                typeOptionsMap = new Map();
-                this.typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
-            }
-            return typeOptionsMap;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager, "typeConfigurationMap", {
-        get: function () {
-            return this.staticTypeManager.typeConfigurationMap;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeManager.prototype, "typeConfigurationMap", {
-        get: function () {
-            var typeConfigurationMap = this.typeManagerOptions.typeConfigurationMap;
-            if (isNil(typeConfigurationMap)) {
-                typeConfigurationMap = new Map();
-                this.typeManagerOptions.typeConfigurationMap = typeConfigurationMap;
-            }
-            return typeConfigurationMap;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TypeManager.prototype.constructTypeManagerOptions = function (typeManagerOptions) {
-        var typeOptionsBase = typeManagerOptions.typeOptionsBase;
-        if (isNil(typeOptionsBase)) {
-            typeOptionsBase = {};
-            typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
-        }
-        var typeOptionsMap = typeManagerOptions.typeOptionsMap;
-        if (isNil(typeOptionsMap)) {
-            typeOptionsMap = new Map();
-            typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
-        }
-        return typeManagerOptions;
-    };
-    TypeManager.prototype.constructTypeOptionsBase = function (typeOptionsBase) {
-        var initialTypeOptionsBase = assign({}, TypeManager.defaultTypeOptionsBase, typeOptionsBase);
-        assign(typeOptionsBase, initialTypeOptionsBase);
-        return typeOptionsBase;
-    };
-    TypeManager.prototype.constructTypeOptionsMap = function (typeOptionsMap) {
-        var e_1, _a, e_2, _b, e_3, _c;
-        var initialTypeOptionsMap = new Map();
-        try {
-            for (var _d = __values(TypeManager.defaultTypeOptionsMap), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var _f = __read(_e.value, 2), typeFn = _f[0], typeOptions = _f[1];
-                var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
-                if (isNil(mapTypeOptions)) {
-                    mapTypeOptions = {};
-                }
-                initialTypeOptionsMap.set(typeFn, assign(mapTypeOptions, typeOptions));
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        try {
-            for (var typeOptionsMap_1 = __values(typeOptionsMap), typeOptionsMap_1_1 = typeOptionsMap_1.next(); !typeOptionsMap_1_1.done; typeOptionsMap_1_1 = typeOptionsMap_1.next()) {
-                var _g = __read(typeOptionsMap_1_1.value, 2), typeFn = _g[0], typeOptions = _g[1];
-                var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
-                if (isNil(mapTypeOptions)) {
-                    mapTypeOptions = {};
-                }
-                initialTypeOptionsMap.set(typeFn, assign(typeOptions, assign(mapTypeOptions, typeOptions)));
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (typeOptionsMap_1_1 && !typeOptionsMap_1_1.done && (_b = typeOptionsMap_1.return)) _b.call(typeOptionsMap_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        typeOptionsMap.clear();
-        try {
-            for (var initialTypeOptionsMap_1 = __values(initialTypeOptionsMap), initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next(); !initialTypeOptionsMap_1_1.done; initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next()) {
-                var _h = __read(initialTypeOptionsMap_1_1.value, 2), typeFn = _h[0], typeOptions = _h[1];
-                typeOptionsMap.set(typeFn, typeOptions);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (initialTypeOptionsMap_1_1 && !initialTypeOptionsMap_1_1.done && (_c = initialTypeOptionsMap_1.return)) _c.call(initialTypeOptionsMap_1);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        return typeOptionsMap;
-    };
-    TypeManager.prototype.constructCustomContext = function () {
-        var _a;
-        var customOptions = (_a = this.typeOptionsBase.customOptions) !== null && _a !== void 0 ? _a : new Array();
-        var customContext = new CustomContext(customOptions);
-        this.typeOptionsBase.customOptions = customOptions;
-        return customContext;
-    };
-    TypeManager.configureTypeMetadata = function (typeFn, typeOptions) {
-        return this.staticTypeManager.configureTypeMetadata(typeFn, typeOptions);
-    };
-    TypeManager.prototype.configureTypeMetadata = function (typeFn, typeOptions) {
-        var symbol = this.symbol;
-        var prototype = typeFn.prototype;
-        var typeMetadataDefined = prototype.hasOwnProperty(symbol);
-        var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.declareTypeMetadata(typeFn, typeOptions);
-        if (!typeMetadataDefined) {
-            Object.defineProperty(prototype, symbol, {
-                enumerable: false,
-                configurable: false,
-                writable: false,
-                value: typeMetadata
-            });
-        }
-        if (typeMetadataDefined && !isNil(typeOptions)) {
-            typeMetadata.configure(typeOptions);
-        }
-        return typeMetadata;
-    };
-    TypeManager.prototype.declareTypeMetadata = function (typeFn, typeOptions) {
-        var _a;
-        var mapTypeOptions = this.typeOptionsMap.get(typeFn);
-        if (isNil(mapTypeOptions)) {
-            mapTypeOptions = typeOptions !== null && typeOptions !== void 0 ? typeOptions : {};
-            this.typeOptionsMap.set(typeFn, mapTypeOptions);
-        }
-        var symbol = this.symbol;
-        var parentPrototype = (_a = Object.getPrototypeOf(typeFn.prototype)) !== null && _a !== void 0 ? _a : {};
-        var parentTypeMetadata = parentPrototype[symbol];
-        var typeMetadata = new TypeMetadata(this, typeFn, mapTypeOptions, parentTypeMetadata);
-        return typeMetadata;
-    };
-    TypeManager.extractTypeMetadata = function (typeFn) {
-        return this.staticTypeManager.extractTypeMetadata(typeFn);
-    };
-    TypeManager.prototype.extractTypeMetadata = function (typeFn) {
-        var symbol = this.symbol;
-        var prototype = typeFn.prototype;
-        var typeMetadataDefined = prototype.hasOwnProperty(symbol);
-        var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.configureTypeMetadata(typeFn);
-        return typeMetadata;
-    };
-    TypeManager.applyTypeOptionsBase = function (typeOptionsBase) {
-        return this.staticTypeManager.applyTypeOptionsBase(typeOptionsBase);
-    };
-    TypeManager.prototype.applyTypeOptionsBase = function (typeOptionsBase) {
-        var customOptions = this.typeOptionsBase.customOptions;
-        assign(this.typeOptionsBase, typeOptionsBase, { customOptions: customOptions });
-        if (!isNil(typeOptionsBase.customOptions)) {
-            this.customContext.configure(typeOptionsBase.customOptions);
-        }
-        return this;
-    };
-    TypeManager.applyTypeOptionsMap = function (typeOptionsMap) {
-        return this.staticTypeManager.applyTypeOptionsMap(typeOptionsMap);
-    };
-    TypeManager.prototype.applyTypeOptionsMap = function (typeOptionsMap) {
-        var e_4, _a;
-        try {
-            for (var typeOptionsMap_2 = __values(typeOptionsMap), typeOptionsMap_2_1 = typeOptionsMap_2.next(); !typeOptionsMap_2_1.done; typeOptionsMap_2_1 = typeOptionsMap_2.next()) {
-                var _b = __read(typeOptionsMap_2_1.value, 2), typeFn = _b[0], typeOptions = _b[1];
-                this.applyTypeOptions(typeFn, typeOptions);
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (typeOptionsMap_2_1 && !typeOptionsMap_2_1.done && (_a = typeOptionsMap_2.return)) _a.call(typeOptionsMap_2);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-        return this;
-    };
-    TypeManager.applyTypeOptions = function (typeFn, typeOptions) {
-        return this.staticTypeManager.applyTypeOptions(typeFn, typeOptions);
-    };
-    TypeManager.prototype.applyTypeOptions = function (typeFn, typeOptions) {
-        var typeMetadata = this.extractTypeMetadata(typeFn);
-        typeMetadata.configure(typeOptions);
-        return this;
-    };
-    TypeManager.applyTypeConfigurationMap = function (typeConfigurationMap) {
-        return this.staticTypeManager.applyTypeConfigurationMap(typeConfigurationMap);
-    };
-    TypeManager.prototype.applyTypeConfigurationMap = function (typeConfigurationMap) {
-        var e_5, _a;
-        try {
-            for (var typeConfigurationMap_1 = __values(typeConfigurationMap), typeConfigurationMap_1_1 = typeConfigurationMap_1.next(); !typeConfigurationMap_1_1.done; typeConfigurationMap_1_1 = typeConfigurationMap_1.next()) {
-                var _b = __read(typeConfigurationMap_1_1.value, 2), typeFn = _b[0], typeConfiguration = _b[1];
-                this.applyTypeConfiguration(typeFn, typeConfiguration);
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (typeConfigurationMap_1_1 && !typeConfigurationMap_1_1.done && (_a = typeConfigurationMap_1.return)) _a.call(typeConfigurationMap_1);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        return this;
-    };
-    TypeManager.applyTypeConfiguration = function (typeFn, typeConfiguration) {
-        return this.staticTypeManager.applyTypeConfiguration(typeFn, typeConfiguration);
-    };
-    TypeManager.prototype.applyTypeConfiguration = function (typeFn, typeConfiguration) {
-        var typeMetadata = this.extractTypeMetadata(typeFn);
-        typeConfiguration.configure(typeMetadata);
-        return this;
-    };
-    TypeManager.configure = function (typeManagerOptions) {
-        return this.staticTypeManager.configure(typeManagerOptions);
-    };
-    TypeManager.prototype.configure = function (typeManagerOptions) {
-        if (!isUndefined(typeManagerOptions.typeOptionsBase)) {
-            this.applyTypeOptionsBase(typeManagerOptions.typeOptionsBase);
-        }
-        if (!isUndefined(typeManagerOptions.typeOptionsMap)) {
-            this.applyTypeOptionsMap(typeManagerOptions.typeOptionsMap);
-        }
-        if (!isUndefined(typeManagerOptions.typeConfigurationMap)) {
-            this.applyTypeConfigurationMap(typeManagerOptions.typeConfigurationMap);
-        }
-        return this;
-    };
-    TypeManager.defineSerializerContext = function (typeFn, x, genericArguments) {
-        return this.staticTypeManager.defineSerializerContext(typeFn, x, genericArguments);
-    };
-    TypeManager.prototype.defineSerializerContext = function (typeFn, x, genericArguments) {
-        var typeMetadata = this.extractTypeMetadata(typeFn);
-        var genericStructures = isNil(genericArguments) ? undefined : typeMetadata.defineGenericStructures(genericArguments);
-        var genericMetadataResolvers = isNil(genericStructures) ? undefined : typeMetadata.defineGenericMetadataResolvers(genericStructures);
-        return new SerializerContext(x, new Map(), new Map(), {
-            jsonPathKey: '$',
-            typeMetadata: typeMetadata,
-            genericStructures: genericStructures,
-            genericMetadataResolvers: genericMetadataResolvers
-        });
-    };
-    TypeManager.serialize = function (typeFn, x) {
-        return this.staticTypeManager.serialize(typeFn, x);
-    };
-    TypeManager.prototype.serialize = function (typeFn, x) {
-        var arrayFn = Array;
-        if (isArray(x) && typeFn !== arrayFn) {
-            return this.defineSerializerContext(arrayFn, x, [typeFn]).serialize(x);
-        }
-        return this.defineSerializerContext(typeFn, x).serialize(x);
-    };
-    TypeManager.deserialize = function (typeFn, x) {
-        return this.staticTypeManager.deserialize(typeFn, x);
-    };
-    TypeManager.prototype.deserialize = function (typeFn, x) {
-        var arrayFn = Array;
-        if (isArray(x) && typeFn !== arrayFn) {
-            return this.defineSerializerContext(arrayFn, x, [typeFn]).deserialize(x);
-        }
-        return this.defineSerializerContext(typeFn, x).deserialize(x);
-    };
-    TypeManager.stringify = function (typeFn, x, replacer, space) {
-        return this.staticTypeManager.stringify(typeFn, x, replacer, space);
-    };
-    TypeManager.prototype.stringify = function (typeFn, x, replacer, space) {
-        return jsonStringify(this.serialize(typeFn, x), replacer, space);
-    };
-    TypeManager.parse = function (typeFn, x, reviver) {
-        return this.staticTypeManager.parse(typeFn, x, reviver);
-    };
-    TypeManager.prototype.parse = function (typeFn, x, reviver) {
-        return this.deserialize(typeFn, jsonParse(x, reviver));
-    };
-    TypeManager.defaultTypeOptionsBase = {
-        discriminator: '$type',
-        factory: new TypeFactory(),
-        injector: new SingletonInjector(),
-        log: new Log(LogLevel.Error),
-        preserveDiscriminator: false,
-        referenceHandler: new CircularReferenceHandler(),
-        serializer: new TypeSerializer(),
-        preserveNull: true,
-        useDefaultValue: false,
-        useImplicitConversion: false
-    };
-    TypeManager.defaultTypeOptionsMap = new Map([
-        [Any, { serializer: new AnySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [ArrayBuffer, { serializer: new ArrayBufferSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Array, { serializer: new ArraySerializer(), serializedDefaultValue: function () { return []; }, deserializedDefaultValue: function () { return []; } }],
-        [Boolean, { serializer: new BooleanSerializer(), serializedDefaultValue: false, deserializedDefaultValue: false }],
-        [DataView, { serializer: new DataViewSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Date, { serializer: new DateSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Float32Array, { serializer: new Float32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Float64Array, { serializer: new Float64ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Int8Array, { serializer: new Int8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Int16Array, { serializer: new Int16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Int32Array, { serializer: new Int32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Map, { serializer: new MapSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Number, { serializer: new NumberSerializer(), serializedDefaultValue: 0, deserializedDefaultValue: 0 }],
-        [Set, { serializer: new SetSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [String, { serializer: new StringSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Uint8Array, { serializer: new Uint8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Uint8ClampedArray, { serializer: new Uint8ClampedArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Uint16Array, { serializer: new Uint16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Uint32Array, { serializer: new Uint32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
-        [Unknown, { serializer: new UnknownSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }]
-    ]);
-    TypeManager.staticTypeManager = new TypeManager();
-    return TypeManager;
-}());
-export { TypeManager };
+import { __read, __values } from "tslib";
+import { assign, isArray, isNil, isUndefined } from 'lodash';
+import { Any } from './any';
+import { CustomContext } from './custom-context';
+import { TypeFactory } from './factories/type-factory';
+import { jsonParse } from './functions/json-parse';
+import { jsonStringify } from './functions/json-stringify';
+import { SingletonInjector } from './injectors/singleton-injector';
+import { Log } from './log';
+import { LogLevel } from './log-level';
+import { CircularReferenceHandler } from './reference-handlers/circular-reference-handler';
+import { SerializerContext } from './serializer-context';
+import { AnySerializer } from './serializers/any-serializer';
+import { ArrayBufferSerializer } from './serializers/array-buffer-serializer';
+import { ArraySerializer } from './serializers/array-serializer';
+import { BooleanSerializer } from './serializers/boolean-serializer';
+import { DataViewSerializer } from './serializers/data-view-serializer';
+import { DateSerializer } from './serializers/date-serializer';
+import { Float32ArraySerializer } from './serializers/float-32-array-serializer';
+import { Float64ArraySerializer } from './serializers/float-64-array-serializer';
+import { Int16ArraySerializer } from './serializers/int-16-array-serializer';
+import { Int32ArraySerializer } from './serializers/int-32-array-serializer';
+import { Int8ArraySerializer } from './serializers/int-8-array-serializer';
+import { MapSerializer } from './serializers/map-serializer';
+import { NumberSerializer } from './serializers/number-serializer';
+import { SetSerializer } from './serializers/set-serializer';
+import { StringSerializer } from './serializers/string-serializer';
+import { TypeSerializer } from './serializers/type-serializer';
+import { Uint16ArraySerializer } from './serializers/uint-16-array-serializer';
+import { Uint32ArraySerializer } from './serializers/uint-32-array-serializer';
+import { Uint8ArraySerializer } from './serializers/uint-8-array-serializer';
+import { Uint8ClampedArraySerializer } from './serializers/uint-8-clamped-array-serializer';
+import { UnknownSerializer } from './serializers/unknown-serializer';
+import { TypeMetadata } from './type-metadata';
+import { typeMetadataSymbol } from './type-metadata-symbol';
+import { Unknown } from './unknown';
+var TypeManager = (function () {
+    function TypeManager(typeManagerOptions) {
+        if (typeManagerOptions === void 0) { typeManagerOptions = {}; }
+        this.typeFnMap = new Map();
+        this.symbol = Symbol(typeMetadataSymbol.description);
+        this.typeManagerOptions = this.constructTypeManagerOptions(typeManagerOptions);
+        this.customContext = this.constructCustomContext();
+        this.configure(typeManagerOptions);
+        return;
+    }
+    Object.defineProperty(TypeManager, "typeFnMap", {
+        get: function () {
+            return this.staticTypeManager.typeFnMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager, "symbol", {
+        get: function () {
+            return this.staticTypeManager.symbol;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager, "typeManagerOptions", {
+        get: function () {
+            return this.staticTypeManager.typeManagerOptions;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager, "typeOptionsBase", {
+        get: function () {
+            return this.staticTypeManager.typeOptionsBase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager.prototype, "typeOptionsBase", {
+        get: function () {
+            var typeOptionsBase = this.typeManagerOptions.typeOptionsBase;
+            if (isNil(typeOptionsBase)) {
+                typeOptionsBase = {};
+                this.typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
+            }
+            return typeOptionsBase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager, "typeOptionsMap", {
+        get: function () {
+            return this.staticTypeManager.typeOptionsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager.prototype, "typeOptionsMap", {
+        get: function () {
+            var typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
+            if (isNil(typeOptionsMap)) {
+                typeOptionsMap = new Map();
+                this.typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
+            }
+            return typeOptionsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager, "typeConfigurationMap", {
+        get: function () {
+            return this.staticTypeManager.typeConfigurationMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeManager.prototype, "typeConfigurationMap", {
+        get: function () {
+            var typeConfigurationMap = this.typeManagerOptions.typeConfigurationMap;
+            if (isNil(typeConfigurationMap)) {
+                typeConfigurationMap = new Map();
+                this.typeManagerOptions.typeConfigurationMap = typeConfigurationMap;
+            }
+            return typeConfigurationMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TypeManager.prototype.constructTypeManagerOptions = function (typeManagerOptions) {
+        var typeOptionsBase = typeManagerOptions.typeOptionsBase;
+        if (isNil(typeOptionsBase)) {
+            typeOptionsBase = {};
+            typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
+        }
+        var typeOptionsMap = typeManagerOptions.typeOptionsMap;
+        if (isNil(typeOptionsMap)) {
+            typeOptionsMap = new Map();
+            typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
+        }
+        return typeManagerOptions;
+    };
+    TypeManager.prototype.constructTypeOptionsBase = function (typeOptionsBase) {
+        var initialTypeOptionsBase = assign({}, TypeManager.defaultTypeOptionsBase, typeOptionsBase);
+        assign(typeOptionsBase, initialTypeOptionsBase);
+        return typeOptionsBase;
+    };
+    TypeManager.prototype.constructTypeOptionsMap = function (typeOptionsMap) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var initialTypeOptionsMap = new Map();
+        try {
+            for (var _d = __values(TypeManager.defaultTypeOptionsMap), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), typeFn = _f[0], typeOptions = _f[1];
+                var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
+                if (isNil(mapTypeOptions)) {
+                    mapTypeOptions = {};
+                }
+                initialTypeOptionsMap.set(typeFn, assign(mapTypeOptions, typeOptions));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var typeOptionsMap_1 = __values(typeOptionsMap), typeOptionsMap_1_1 = typeOptionsMap_1.next(); !typeOptionsMap_1_1.done; typeOptionsMap_1_1 = typeOptionsMap_1.next()) {
+                var _g = __read(typeOptionsMap_1_1.value, 2), typeFn = _g[0], typeOptions = _g[1];
+                var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
+                if (isNil(mapTypeOptions)) {
+                    mapTypeOptions = {};
+                }
+                initialTypeOptionsMap.set(typeFn, assign(typeOptions, assign(mapTypeOptions, typeOptions)));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (typeOptionsMap_1_1 && !typeOptionsMap_1_1.done && (_b = typeOptionsMap_1.return)) _b.call(typeOptionsMap_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        typeOptionsMap.clear();
+        try {
+            for (var initialTypeOptionsMap_1 = __values(initialTypeOptionsMap), initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next(); !initialTypeOptionsMap_1_1.done; initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next()) {
+                var _h = __read(initialTypeOptionsMap_1_1.value, 2), typeFn = _h[0], typeOptions = _h[1];
+                typeOptionsMap.set(typeFn, typeOptions);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (initialTypeOptionsMap_1_1 && !initialTypeOptionsMap_1_1.done && (_c = initialTypeOptionsMap_1.return)) _c.call(initialTypeOptionsMap_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return typeOptionsMap;
+    };
+    TypeManager.prototype.constructCustomContext = function () {
+        var _a;
+        var customOptions = (_a = this.typeOptionsBase.customOptions) !== null && _a !== void 0 ? _a : new Array();
+        var customContext = new CustomContext(customOptions);
+        this.typeOptionsBase.customOptions = customOptions;
+        return customContext;
+    };
+    TypeManager.configureTypeMetadata = function (typeFn, typeOptions) {
+        return this.staticTypeManager.configureTypeMetadata(typeFn, typeOptions);
+    };
+    TypeManager.prototype.configureTypeMetadata = function (typeFn, typeOptions) {
+        var symbol = this.symbol;
+        var prototype = typeFn.prototype;
+        var typeMetadataDefined = prototype.hasOwnProperty(symbol);
+        var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.declareTypeMetadata(typeFn, typeOptions);
+        if (!typeMetadataDefined) {
+            Object.defineProperty(prototype, symbol, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: typeMetadata
+            });
+        }
+        if (typeMetadataDefined && !isNil(typeOptions)) {
+            typeMetadata.configure(typeOptions);
+        }
+        return typeMetadata;
+    };
+    TypeManager.prototype.declareTypeMetadata = function (typeFn, typeOptions) {
+        var _a;
+        var mapTypeOptions = this.typeOptionsMap.get(typeFn);
+        if (isNil(mapTypeOptions)) {
+            mapTypeOptions = typeOptions !== null && typeOptions !== void 0 ? typeOptions : {};
+            this.typeOptionsMap.set(typeFn, mapTypeOptions);
+        }
+        var symbol = this.symbol;
+        var parentPrototype = (_a = Object.getPrototypeOf(typeFn.prototype)) !== null && _a !== void 0 ? _a : {};
+        var parentTypeMetadata = parentPrototype[symbol];
+        var typeMetadata = new TypeMetadata(this, typeFn, mapTypeOptions, parentTypeMetadata);
+        return typeMetadata;
+    };
+    TypeManager.extractTypeMetadata = function (typeFn) {
+        return this.staticTypeManager.extractTypeMetadata(typeFn);
+    };
+    TypeManager.prototype.extractTypeMetadata = function (typeFn) {
+        var symbol = this.symbol;
+        var prototype = typeFn.prototype;
+        var typeMetadataDefined = prototype.hasOwnProperty(symbol);
+        var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.configureTypeMetadata(typeFn);
+        return typeMetadata;
+    };
+    TypeManager.applyTypeOptionsBase = function (typeOptionsBase) {
+        return this.staticTypeManager.applyTypeOptionsBase(typeOptionsBase);
+    };
+    TypeManager.prototype.applyTypeOptionsBase = function (typeOptionsBase) {
+        var customOptions = this.typeOptionsBase.customOptions;
+        assign(this.typeOptionsBase, typeOptionsBase, { customOptions: customOptions });
+        if (!isNil(typeOptionsBase.customOptions)) {
+            this.customContext.configure(typeOptionsBase.customOptions);
+        }
+        return this;
+    };
+    TypeManager.applyTypeOptionsMap = function (typeOptionsMap) {
+        return this.staticTypeManager.applyTypeOptionsMap(typeOptionsMap);
+    };
+    TypeManager.prototype.applyTypeOptionsMap = function (typeOptionsMap) {
+        var e_4, _a;
+        try {
+            for (var typeOptionsMap_2 = __values(typeOptionsMap), typeOptionsMap_2_1 = typeOptionsMap_2.next(); !typeOptionsMap_2_1.done; typeOptionsMap_2_1 = typeOptionsMap_2.next()) {
+                var _b = __read(typeOptionsMap_2_1.value, 2), typeFn = _b[0], typeOptions = _b[1];
+                this.applyTypeOptions(typeFn, typeOptions);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (typeOptionsMap_2_1 && !typeOptionsMap_2_1.done && (_a = typeOptionsMap_2.return)) _a.call(typeOptionsMap_2);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return this;
+    };
+    TypeManager.applyTypeOptions = function (typeFn, typeOptions) {
+        return this.staticTypeManager.applyTypeOptions(typeFn, typeOptions);
+    };
+    TypeManager.prototype.applyTypeOptions = function (typeFn, typeOptions) {
+        var typeMetadata = this.extractTypeMetadata(typeFn);
+        typeMetadata.configure(typeOptions);
+        return this;
+    };
+    TypeManager.applyTypeConfigurationMap = function (typeConfigurationMap) {
+        return this.staticTypeManager.applyTypeConfigurationMap(typeConfigurationMap);
+    };
+    TypeManager.prototype.applyTypeConfigurationMap = function (typeConfigurationMap) {
+        var e_5, _a;
+        try {
+            for (var typeConfigurationMap_1 = __values(typeConfigurationMap), typeConfigurationMap_1_1 = typeConfigurationMap_1.next(); !typeConfigurationMap_1_1.done; typeConfigurationMap_1_1 = typeConfigurationMap_1.next()) {
+                var _b = __read(typeConfigurationMap_1_1.value, 2), typeFn = _b[0], typeConfiguration = _b[1];
+                this.applyTypeConfiguration(typeFn, typeConfiguration);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (typeConfigurationMap_1_1 && !typeConfigurationMap_1_1.done && (_a = typeConfigurationMap_1.return)) _a.call(typeConfigurationMap_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return this;
+    };
+    TypeManager.applyTypeConfiguration = function (typeFn, typeConfiguration) {
+        return this.staticTypeManager.applyTypeConfiguration(typeFn, typeConfiguration);
+    };
+    TypeManager.prototype.applyTypeConfiguration = function (typeFn, typeConfiguration) {
+        var typeMetadata = this.extractTypeMetadata(typeFn);
+        typeConfiguration.configure(typeMetadata);
+        return this;
+    };
+    TypeManager.configure = function (typeManagerOptions) {
+        return this.staticTypeManager.configure(typeManagerOptions);
+    };
+    TypeManager.prototype.configure = function (typeManagerOptions) {
+        if (!isUndefined(typeManagerOptions.typeOptionsBase)) {
+            this.applyTypeOptionsBase(typeManagerOptions.typeOptionsBase);
+        }
+        if (!isUndefined(typeManagerOptions.typeOptionsMap)) {
+            this.applyTypeOptionsMap(typeManagerOptions.typeOptionsMap);
+        }
+        if (!isUndefined(typeManagerOptions.typeConfigurationMap)) {
+            this.applyTypeConfigurationMap(typeManagerOptions.typeConfigurationMap);
+        }
+        return this;
+    };
+    TypeManager.defineSerializerContext = function (typeFn, x, genericArguments) {
+        return this.staticTypeManager.defineSerializerContext(typeFn, x, genericArguments);
+    };
+    TypeManager.prototype.defineSerializerContext = function (typeFn, x, genericArguments) {
+        var typeMetadata = this.extractTypeMetadata(typeFn);
+        var genericStructures = isNil(genericArguments) ? undefined : typeMetadata.defineGenericStructures(genericArguments);
+        var genericMetadataResolvers = isNil(genericStructures) ? undefined : typeMetadata.defineGenericMetadataResolvers(genericStructures);
+        return new SerializerContext(x, new Map(), new Map(), {
+            jsonPathKey: '$',
+            typeMetadata: typeMetadata,
+            genericStructures: genericStructures,
+            genericMetadataResolvers: genericMetadataResolvers
+        });
+    };
+    TypeManager.serialize = function (typeFn, x) {
+        return this.staticTypeManager.serialize(typeFn, x);
+    };
+    TypeManager.prototype.serialize = function (typeFn, x) {
+        var arrayFn = Array;
+        if (isArray(x) && typeFn !== arrayFn) {
+            return this.defineSerializerContext(arrayFn, x, [typeFn]).serialize(x);
+        }
+        return this.defineSerializerContext(typeFn, x).serialize(x);
+    };
+    TypeManager.deserialize = function (typeFn, x) {
+        return this.staticTypeManager.deserialize(typeFn, x);
+    };
+    TypeManager.prototype.deserialize = function (typeFn, x) {
+        var arrayFn = Array;
+        if (isArray(x) && typeFn !== arrayFn) {
+            return this.defineSerializerContext(arrayFn, x, [typeFn]).deserialize(x);
+        }
+        return this.defineSerializerContext(typeFn, x).deserialize(x);
+    };
+    TypeManager.stringify = function (typeFn, x, replacer, space) {
+        return this.staticTypeManager.stringify(typeFn, x, replacer, space);
+    };
+    TypeManager.prototype.stringify = function (typeFn, x, replacer, space) {
+        return jsonStringify(this.serialize(typeFn, x), replacer, space);
+    };
+    TypeManager.parse = function (typeFn, x, reviver) {
+        return this.staticTypeManager.parse(typeFn, x, reviver);
+    };
+    TypeManager.prototype.parse = function (typeFn, x, reviver) {
+        return this.deserialize(typeFn, jsonParse(x, reviver));
+    };
+    TypeManager.defaultTypeOptionsBase = {
+        discriminator: '$type',
+        factory: new TypeFactory(),
+        injector: new SingletonInjector(),
+        log: new Log(LogLevel.Error),
+        preserveDiscriminator: false,
+        referenceHandler: new CircularReferenceHandler(),
+        serializer: new TypeSerializer(),
+        preserveNull: true,
+        useDefaultValue: false,
+        useImplicitConversion: false
+    };
+    TypeManager.defaultTypeOptionsMap = new Map([
+        [Any, { serializer: new AnySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [ArrayBuffer, { serializer: new ArrayBufferSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Array, { serializer: new ArraySerializer(), serializedDefaultValue: function () { return []; }, deserializedDefaultValue: function () { return []; } }],
+        [Boolean, { serializer: new BooleanSerializer(), serializedDefaultValue: false, deserializedDefaultValue: false }],
+        [DataView, { serializer: new DataViewSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Date, { serializer: new DateSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Float32Array, { serializer: new Float32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Float64Array, { serializer: new Float64ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Int8Array, { serializer: new Int8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Int16Array, { serializer: new Int16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Int32Array, { serializer: new Int32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Map, { serializer: new MapSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Number, { serializer: new NumberSerializer(), serializedDefaultValue: 0, deserializedDefaultValue: 0 }],
+        [Set, { serializer: new SetSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [String, { serializer: new StringSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Uint8Array, { serializer: new Uint8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Uint8ClampedArray, { serializer: new Uint8ClampedArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Uint16Array, { serializer: new Uint16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Uint32Array, { serializer: new Uint32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
+        [Unknown, { serializer: new UnknownSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }]
+    ]);
+    TypeManager.staticTypeManager = new TypeManager();
+    return TypeManager;
+}());
+export { TypeManager };
 //# sourceMappingURL=type-manager.js.map