@dipscope/type-manager 6.0.0 → 7.0.0

package/dist/es2015/type-manager.js

@@ -1,314 +1,320 @@
-import { isArray, isNil, isUndefined, merge } from 'lodash';
-import { Any } from './any';
-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';
-export class TypeManager {
-    constructor(typeManagerOptions = {}) {
-        this.typeFnMap = new Map();
-        this.symbol = Symbol(typeMetadataSymbol.description);
-        this.typeManagerOptions = this.constructTypeManagerOptions(typeManagerOptions);
-        this.configure(typeManagerOptions);
-        return;
-    }
-    static get typeFnMap() {
-        return this.staticTypeManager.typeFnMap;
-    }
-    static get symbol() {
-        return this.staticTypeManager.symbol;
-    }
-    static get typeManagerOptions() {
-        return this.staticTypeManager.typeManagerOptions;
-    }
-    static get typeOptionsBase() {
-        return this.staticTypeManager.typeOptionsBase;
-    }
-    get typeOptionsBase() {
-        let typeOptionsBase = this.typeManagerOptions.typeOptionsBase;
-        if (isNil(typeOptionsBase)) {
-            typeOptionsBase = merge({}, TypeManager.defaultTypeOptionsBase);
-            this.typeManagerOptions.typeOptionsBase = typeOptionsBase;
-        }
-        return typeOptionsBase;
-    }
-    static get typeOptionsMap() {
-        return this.staticTypeManager.typeOptionsMap;
-    }
-    get typeOptionsMap() {
-        let typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
-        if (isNil(typeOptionsMap)) {
-            typeOptionsMap = new Map(TypeManager.defaultTypeOptionsMap.entries());
-            this.typeManagerOptions.typeOptionsMap = typeOptionsMap;
-        }
-        return typeOptionsMap;
-    }
-    static get typeConfigurationMap() {
-        return this.staticTypeManager.typeConfigurationMap;
-    }
-    get typeConfigurationMap() {
-        let typeConfigurationMap = this.typeManagerOptions.typeConfigurationMap;
-        if (isNil(typeConfigurationMap)) {
-            typeConfigurationMap = new Map();
-            this.typeManagerOptions.typeConfigurationMap = typeConfigurationMap;
-        }
-        return typeConfigurationMap;
-    }
-    constructTypeManagerOptions(typeManagerOptions) {
-        let typeOptionsBase = typeManagerOptions.typeOptionsBase;
-        if (isNil(typeOptionsBase)) {
-            typeOptionsBase = {};
-            typeManagerOptions.typeOptionsBase = typeOptionsBase;
-        }
-        this.constructTypeOptionsBase(typeOptionsBase);
-        let typeOptionsMap = typeManagerOptions.typeOptionsMap;
-        if (isNil(typeOptionsMap)) {
-            typeOptionsMap = new Map();
-            typeManagerOptions.typeOptionsMap = typeOptionsMap;
-        }
-        this.constructTypeOptionsMap(typeOptionsMap);
-        return typeManagerOptions;
-    }
-    constructTypeOptionsBase(typeOptionsBase) {
-        const initialTypeOptionsBase = merge({}, TypeManager.defaultTypeOptionsBase, typeOptionsBase);
-        merge(typeOptionsBase, initialTypeOptionsBase);
-        return typeOptionsBase;
-    }
-    constructTypeOptionsMap(typeOptionsMap) {
-        const initialTypeOptionsMap = new Map();
-        for (const [typeFn, typeOptions] of TypeManager.defaultTypeOptionsMap) {
-            let mapTypeOptions = initialTypeOptionsMap.get(typeFn);
-            if (isNil(mapTypeOptions)) {
-                mapTypeOptions = {};
-            }
-            initialTypeOptionsMap.set(typeFn, merge(mapTypeOptions, typeOptions));
-        }
-        for (const [typeFn, typeOptions] of typeOptionsMap) {
-            let mapTypeOptions = initialTypeOptionsMap.get(typeFn);
-            if (isNil(mapTypeOptions)) {
-                mapTypeOptions = {};
-            }
-            initialTypeOptionsMap.set(typeFn, merge(typeOptions, merge(mapTypeOptions, typeOptions)));
-        }
-        typeOptionsMap.clear();
-        for (const [typeFn, typeOptions] of initialTypeOptionsMap) {
-            typeOptionsMap.set(typeFn, typeOptions);
-        }
-        return typeOptionsMap;
-    }
-    static configureTypeMetadata(typeFn, typeOptions) {
-        return this.staticTypeManager.configureTypeMetadata(typeFn, typeOptions);
-    }
-    configureTypeMetadata(typeFn, typeOptions) {
-        const symbol = this.symbol;
-        const prototype = typeFn.prototype;
-        const typeMetadataDefined = prototype.hasOwnProperty(symbol);
-        const typeMetadata = typeMetadataDefined ? prototype[symbol] : this.declareTypeMetadata(typeFn);
-        if (!typeMetadataDefined) {
-            Object.defineProperty(prototype, symbol, {
-                enumerable: false,
-                configurable: false,
-                writable: false,
-                value: typeMetadata
-            });
-        }
-        if (!isNil(typeOptions)) {
-            typeMetadata.configure(typeOptions);
-        }
-        return typeMetadata;
-    }
-    declareTypeMetadata(typeFn) {
-        var _a;
-        let typeOptions = this.typeOptionsMap.get(typeFn);
-        if (isNil(typeOptions)) {
-            typeOptions = {};
-            this.typeOptionsMap.set(typeFn, typeOptions);
-        }
-        const symbol = this.symbol;
-        const typeMetadataExtractor = this.extractTypeMetadata.bind(this);
-        const typeFnMap = this.typeFnMap;
-        const typeOptionsBase = this.typeOptionsBase;
-        const parentPrototype = (_a = Object.getPrototypeOf(typeFn.prototype)) !== null && _a !== void 0 ? _a : {};
-        const parentTypeMetadata = parentPrototype[symbol];
-        const typeMetadata = new TypeMetadata(typeMetadataExtractor, typeFnMap, typeFn, typeOptionsBase, typeOptions, parentTypeMetadata);
-        return typeMetadata;
-    }
-    static extractTypeMetadata(typeFn) {
-        return this.staticTypeManager.extractTypeMetadata(typeFn);
-    }
-    extractTypeMetadata(typeFn) {
-        const symbol = this.symbol;
-        const prototype = typeFn.prototype;
-        const typeMetadataDefined = prototype.hasOwnProperty(symbol);
-        const typeMetadata = typeMetadataDefined ? prototype[symbol] : this.configureTypeMetadata(typeFn);
-        return typeMetadata;
-    }
-    static applyTypeOptionsBase(typeOptionsBase) {
-        return this.staticTypeManager.applyTypeOptionsBase(typeOptionsBase);
-    }
-    applyTypeOptionsBase(typeOptionsBase) {
-        merge(this.typeOptionsBase, typeOptionsBase);
-        return this;
-    }
-    static applyTypeOptionsMap(typeOptionsMap) {
-        return this.staticTypeManager.applyTypeOptionsMap(typeOptionsMap);
-    }
-    applyTypeOptionsMap(typeOptionsMap) {
-        for (const [typeFn, typeOptions] of typeOptionsMap) {
-            this.applyTypeOptions(typeFn, typeOptions);
-        }
-        return this;
-    }
-    static applyTypeOptions(typeFn, typeOptions) {
-        return this.staticTypeManager.applyTypeOptions(typeFn, typeOptions);
-    }
-    applyTypeOptions(typeFn, typeOptions) {
-        const typeMetadata = this.extractTypeMetadata(typeFn);
-        typeMetadata.configure(typeOptions);
-        return this;
-    }
-    static applyTypeConfigurationMap(typeConfigurationMap) {
-        return this.staticTypeManager.applyTypeConfigurationMap(typeConfigurationMap);
-    }
-    applyTypeConfigurationMap(typeConfigurationMap) {
-        for (const [typeFn, typeConfiguration] of typeConfigurationMap) {
-            this.applyTypeConfiguration(typeFn, typeConfiguration);
-        }
-        return this;
-    }
-    static applyTypeConfiguration(typeFn, typeConfiguration) {
-        return this.staticTypeManager.applyTypeConfiguration(typeFn, typeConfiguration);
-    }
-    applyTypeConfiguration(typeFn, typeConfiguration) {
-        const typeMetadata = this.extractTypeMetadata(typeFn);
-        typeConfiguration.configure(typeMetadata);
-        return this;
-    }
-    static configure(typeManagerOptions) {
-        return this.staticTypeManager.configure(typeManagerOptions);
-    }
-    configure(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;
-    }
-    static defineSerializerContext(typeFn, x, genericArguments) {
-        return this.staticTypeManager.defineSerializerContext(typeFn, x, genericArguments);
-    }
-    defineSerializerContext(typeFn, x, genericArguments) {
-        const typeMetadata = this.extractTypeMetadata(typeFn);
-        const genericStructures = isNil(genericArguments) ? undefined : typeMetadata.defineGenericStructures(genericArguments);
-        const genericMetadataResolvers = isNil(genericStructures) ? undefined : typeMetadata.defineGenericMetadataResolvers(genericStructures);
-        return new SerializerContext(x, new Map(), new Map(), {
-            jsonPathKey: '$',
-            typeMetadata: typeMetadata,
-            genericStructures: genericStructures,
-            genericMetadataResolvers: genericMetadataResolvers
-        });
-    }
-    static serialize(typeFn, x) {
-        return this.staticTypeManager.serialize(typeFn, x);
-    }
-    serialize(typeFn, x) {
-        const arrayFn = Array;
-        if (isArray(x) && typeFn !== arrayFn) {
-            return this.defineSerializerContext(arrayFn, x, [typeFn]).serialize(x);
-        }
-        return this.defineSerializerContext(typeFn, x).serialize(x);
-    }
-    static deserialize(typeFn, x) {
-        return this.staticTypeManager.deserialize(typeFn, x);
-    }
-    deserialize(typeFn, x) {
-        const arrayFn = Array;
-        if (isArray(x) && typeFn !== arrayFn) {
-            return this.defineSerializerContext(arrayFn, x, [typeFn]).deserialize(x);
-        }
-        return this.defineSerializerContext(typeFn, x).deserialize(x);
-    }
-    static stringify(typeFn, x, replacer, space) {
-        return this.staticTypeManager.stringify(typeFn, x, replacer, space);
-    }
-    stringify(typeFn, x, replacer, space) {
-        return jsonStringify(this.serialize(typeFn, x), replacer, space);
-    }
-    static parse(typeFn, x, reviver) {
-        return this.staticTypeManager.parse(typeFn, x, reviver);
-    }
-    parse(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,
-    propertySorter: undefined,
-    injectSorter: undefined
-};
-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: () => [], deserializedDefaultValue: () => [] }],
-    [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();
+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';
+export class TypeManager {
+    constructor(typeManagerOptions = {}) {
+        this.typeFnMap = new Map();
+        this.symbol = Symbol(typeMetadataSymbol.description);
+        this.typeManagerOptions = this.constructTypeManagerOptions(typeManagerOptions);
+        this.customContext = this.constructCustomContext();
+        this.configure(typeManagerOptions);
+        return;
+    }
+    static get typeFnMap() {
+        return this.staticTypeManager.typeFnMap;
+    }
+    static get symbol() {
+        return this.staticTypeManager.symbol;
+    }
+    static get typeManagerOptions() {
+        return this.staticTypeManager.typeManagerOptions;
+    }
+    static get typeOptionsBase() {
+        return this.staticTypeManager.typeOptionsBase;
+    }
+    get typeOptionsBase() {
+        let typeOptionsBase = this.typeManagerOptions.typeOptionsBase;
+        if (isNil(typeOptionsBase)) {
+            typeOptionsBase = {};
+            this.typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
+        }
+        return typeOptionsBase;
+    }
+    static get typeOptionsMap() {
+        return this.staticTypeManager.typeOptionsMap;
+    }
+    get typeOptionsMap() {
+        let typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
+        if (isNil(typeOptionsMap)) {
+            typeOptionsMap = new Map();
+            this.typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
+        }
+        return typeOptionsMap;
+    }
+    static get typeConfigurationMap() {
+        return this.staticTypeManager.typeConfigurationMap;
+    }
+    get typeConfigurationMap() {
+        let typeConfigurationMap = this.typeManagerOptions.typeConfigurationMap;
+        if (isNil(typeConfigurationMap)) {
+            typeConfigurationMap = new Map();
+            this.typeManagerOptions.typeConfigurationMap = typeConfigurationMap;
+        }
+        return typeConfigurationMap;
+    }
+    constructTypeManagerOptions(typeManagerOptions) {
+        let typeOptionsBase = typeManagerOptions.typeOptionsBase;
+        if (isNil(typeOptionsBase)) {
+            typeOptionsBase = {};
+            typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
+        }
+        let typeOptionsMap = typeManagerOptions.typeOptionsMap;
+        if (isNil(typeOptionsMap)) {
+            typeOptionsMap = new Map();
+            typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
+        }
+        return typeManagerOptions;
+    }
+    constructTypeOptionsBase(typeOptionsBase) {
+        const initialTypeOptionsBase = assign({}, TypeManager.defaultTypeOptionsBase, typeOptionsBase);
+        assign(typeOptionsBase, initialTypeOptionsBase);
+        return typeOptionsBase;
+    }
+    constructTypeOptionsMap(typeOptionsMap) {
+        const initialTypeOptionsMap = new Map();
+        for (const [typeFn, typeOptions] of TypeManager.defaultTypeOptionsMap) {
+            let mapTypeOptions = initialTypeOptionsMap.get(typeFn);
+            if (isNil(mapTypeOptions)) {
+                mapTypeOptions = {};
+            }
+            initialTypeOptionsMap.set(typeFn, assign(mapTypeOptions, typeOptions));
+        }
+        for (const [typeFn, typeOptions] of typeOptionsMap) {
+            let mapTypeOptions = initialTypeOptionsMap.get(typeFn);
+            if (isNil(mapTypeOptions)) {
+                mapTypeOptions = {};
+            }
+            initialTypeOptionsMap.set(typeFn, assign(typeOptions, assign(mapTypeOptions, typeOptions)));
+        }
+        typeOptionsMap.clear();
+        for (const [typeFn, typeOptions] of initialTypeOptionsMap) {
+            typeOptionsMap.set(typeFn, typeOptions);
+        }
+        return typeOptionsMap;
+    }
+    constructCustomContext() {
+        var _a;
+        const customOptions = (_a = this.typeOptionsBase.customOptions) !== null && _a !== void 0 ? _a : new Array();
+        const customContext = new CustomContext(customOptions);
+        this.typeOptionsBase.customOptions = customOptions;
+        return customContext;
+    }
+    static configureTypeMetadata(typeFn, typeOptions) {
+        return this.staticTypeManager.configureTypeMetadata(typeFn, typeOptions);
+    }
+    configureTypeMetadata(typeFn, typeOptions) {
+        const symbol = this.symbol;
+        const prototype = typeFn.prototype;
+        const typeMetadataDefined = prototype.hasOwnProperty(symbol);
+        const 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;
+    }
+    declareTypeMetadata(typeFn, typeOptions) {
+        var _a;
+        let mapTypeOptions = this.typeOptionsMap.get(typeFn);
+        if (isNil(mapTypeOptions)) {
+            mapTypeOptions = typeOptions !== null && typeOptions !== void 0 ? typeOptions : {};
+            this.typeOptionsMap.set(typeFn, mapTypeOptions);
+        }
+        const symbol = this.symbol;
+        const parentPrototype = (_a = Object.getPrototypeOf(typeFn.prototype)) !== null && _a !== void 0 ? _a : {};
+        const parentTypeMetadata = parentPrototype[symbol];
+        const typeMetadata = new TypeMetadata(this, typeFn, mapTypeOptions, parentTypeMetadata);
+        return typeMetadata;
+    }
+    static extractTypeMetadata(typeFn) {
+        return this.staticTypeManager.extractTypeMetadata(typeFn);
+    }
+    extractTypeMetadata(typeFn) {
+        const symbol = this.symbol;
+        const prototype = typeFn.prototype;
+        const typeMetadataDefined = prototype.hasOwnProperty(symbol);
+        const typeMetadata = typeMetadataDefined ? prototype[symbol] : this.configureTypeMetadata(typeFn);
+        return typeMetadata;
+    }
+    static applyTypeOptionsBase(typeOptionsBase) {
+        return this.staticTypeManager.applyTypeOptionsBase(typeOptionsBase);
+    }
+    applyTypeOptionsBase(typeOptionsBase) {
+        const customOptions = this.typeOptionsBase.customOptions;
+        assign(this.typeOptionsBase, typeOptionsBase, { customOptions: customOptions });
+        if (!isNil(typeOptionsBase.customOptions)) {
+            this.customContext.configure(typeOptionsBase.customOptions);
+        }
+        return this;
+    }
+    static applyTypeOptionsMap(typeOptionsMap) {
+        return this.staticTypeManager.applyTypeOptionsMap(typeOptionsMap);
+    }
+    applyTypeOptionsMap(typeOptionsMap) {
+        for (const [typeFn, typeOptions] of typeOptionsMap) {
+            this.applyTypeOptions(typeFn, typeOptions);
+        }
+        return this;
+    }
+    static applyTypeOptions(typeFn, typeOptions) {
+        return this.staticTypeManager.applyTypeOptions(typeFn, typeOptions);
+    }
+    applyTypeOptions(typeFn, typeOptions) {
+        const typeMetadata = this.extractTypeMetadata(typeFn);
+        typeMetadata.configure(typeOptions);
+        return this;
+    }
+    static applyTypeConfigurationMap(typeConfigurationMap) {
+        return this.staticTypeManager.applyTypeConfigurationMap(typeConfigurationMap);
+    }
+    applyTypeConfigurationMap(typeConfigurationMap) {
+        for (const [typeFn, typeConfiguration] of typeConfigurationMap) {
+            this.applyTypeConfiguration(typeFn, typeConfiguration);
+        }
+        return this;
+    }
+    static applyTypeConfiguration(typeFn, typeConfiguration) {
+        return this.staticTypeManager.applyTypeConfiguration(typeFn, typeConfiguration);
+    }
+    applyTypeConfiguration(typeFn, typeConfiguration) {
+        const typeMetadata = this.extractTypeMetadata(typeFn);
+        typeConfiguration.configure(typeMetadata);
+        return this;
+    }
+    static configure(typeManagerOptions) {
+        return this.staticTypeManager.configure(typeManagerOptions);
+    }
+    configure(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;
+    }
+    static defineSerializerContext(typeFn, x, genericArguments) {
+        return this.staticTypeManager.defineSerializerContext(typeFn, x, genericArguments);
+    }
+    defineSerializerContext(typeFn, x, genericArguments) {
+        const typeMetadata = this.extractTypeMetadata(typeFn);
+        const genericStructures = isNil(genericArguments) ? undefined : typeMetadata.defineGenericStructures(genericArguments);
+        const genericMetadataResolvers = isNil(genericStructures) ? undefined : typeMetadata.defineGenericMetadataResolvers(genericStructures);
+        return new SerializerContext(x, new Map(), new Map(), {
+            jsonPathKey: '$',
+            typeMetadata: typeMetadata,
+            genericStructures: genericStructures,
+            genericMetadataResolvers: genericMetadataResolvers
+        });
+    }
+    static serialize(typeFn, x) {
+        return this.staticTypeManager.serialize(typeFn, x);
+    }
+    serialize(typeFn, x) {
+        const arrayFn = Array;
+        if (isArray(x) && typeFn !== arrayFn) {
+            return this.defineSerializerContext(arrayFn, x, [typeFn]).serialize(x);
+        }
+        return this.defineSerializerContext(typeFn, x).serialize(x);
+    }
+    static deserialize(typeFn, x) {
+        return this.staticTypeManager.deserialize(typeFn, x);
+    }
+    deserialize(typeFn, x) {
+        const arrayFn = Array;
+        if (isArray(x) && typeFn !== arrayFn) {
+            return this.defineSerializerContext(arrayFn, x, [typeFn]).deserialize(x);
+        }
+        return this.defineSerializerContext(typeFn, x).deserialize(x);
+    }
+    static stringify(typeFn, x, replacer, space) {
+        return this.staticTypeManager.stringify(typeFn, x, replacer, space);
+    }
+    stringify(typeFn, x, replacer, space) {
+        return jsonStringify(this.serialize(typeFn, x), replacer, space);
+    }
+    static parse(typeFn, x, reviver) {
+        return this.staticTypeManager.parse(typeFn, x, reviver);
+    }
+    parse(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: () => [], deserializedDefaultValue: () => [] }],
+    [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();
 //# sourceMappingURL=type-manager.js.map