@dipscope/type-manager 7.2.0 → 8.0.0

package/dist/types/type-metadata.d.ts

@@ -1,7 +1,7 @@
 import { Alias } from './alias';
-import { CustomContext } from './custom-context';
 import { CustomKey } from './custom-key';
 import { CustomOption } from './custom-option';
+import { CustomValue } from './custom-value';
 import { DefaultValue } from './default-value';
 import { Discriminant } from './discriminant';
 import { Discriminator } from './discriminator';
@@ -11,30 +11,34 @@ import { InjectMetadata } from './inject-metadata';
 import { InjectOptions } from './inject-options';
 import { InjectSorter } from './inject-sorter';
 import { Injector } from './injector';
-import { Log } from './log';
+import { Logger } from './logger';
 import { Metadata } from './metadata';
 import { NamingConvention } from './naming-convention';
+import { Nullable } from './nullable';
+import { Optional } from './optional';
 import { PropertyMetadata } from './property-metadata';
 import { PropertyName } from './property-name';
 import { PropertyOptions } from './property-options';
 import { PropertySorter } from './property-sorter';
 import { ReferenceHandler } from './reference-handler';
 import { Serializer } from './serializer';
+import { TypeArgument } from './type-argument';
 import { TypeExtensionMetadata } from './type-extension-metadata';
 import { TypeExtensionMetadataCtor } from './type-extension-metadata-ctor';
 import { TypeExtensionOptions } from './type-extension-options';
 import { TypeFn } from './type-fn';
-import { TypeInternals } from './type-internals';
 import { TypeManager } from './type-manager';
 import { TypeName } from './type-name';
 import { TypeOptions } from './type-options';
-import { TypeOptionsBase } from './type-options-base';
+import { TypeState } from './type-state';
+import { ResolvedTypeState } from './type-states/resolved-type-state';
+import { UnresolvedTypeState } from './type-states/unresolved-type-state';
 /**
  * Main class used to describe a certain type.
  *
- * @type {TypeMetadata<TType>}
+ * @type {TypeMetadata<TObject>}
  */
-export declare class TypeMetadata<TType> extends Metadata {
+export declare class TypeMetadata<TObject> extends Metadata {
     /**
      * Type name.
      *
@@ -46,114 +50,128 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Type function.
      *
-     * @type {TypeFn<TType>}
+     * @type {TypeFn<TObject>}
      */
-    readonly typeFn: TypeFn<TType>;
+    readonly typeFn: TypeFn<TObject>;
     /**
-     * Type options used by default.
+     * Parent type metadata.
+     *
+     * @type {Optional<TypeMetadata<any>>}
+     */
+    readonly parentTypeMetadata: Optional<TypeMetadata<any>>;
+    /**
+     * Type options used as a fallback.
      *
-     * @type {TypeOptionsBase<TType>}
+     * @type {TypeOptionsBase<TObject>}
      */
-    readonly typeOptionsBase: TypeOptionsBase<TType>;
+    private readonly typeOptionsBase;
     /**
      * Type options.
      *
-     * @type {TypeOptions<TType>}
+     * @type {TypeOptions<TObject>}
      */
-    readonly typeOptions: TypeOptions<TType>;
+    private readonly typeOptions;
     /**
-     * Type internals.
+     * Type metadata set.
      *
-     * @type {TypeInternals}
+     * @type {ReadonlySet<TypeMetadata<any>>}
      */
-    readonly typeInternals: TypeInternals;
+    private readonly typeMetadataSet;
     /**
-     * Children type metadata map.
+     * Current type function map.
      *
-     * @type {Map<TypeFn<TType>, TypeMetadata<any>>}
+     * @type {Map<Alias, TypeFn<any>>}
      */
-    readonly childrenTypeMetadataMap: Map<TypeFn<any>, TypeMetadata<any>>;
+    private readonly currentTypeFnMap;
     /**
-     * Discriminant map.
+     * Current child type metadata map.
      *
-     * @type {Map<TypeFn<any>, Discriminant>}
+     * @type {Map<TypeFn<TObject>, TypeMetadata<any>>}
      */
-    readonly discriminantMap: Map<TypeFn<any>, Discriminant>;
+    private readonly currentChildTypeMetadataMap;
     /**
-     * Properties defined for a type.
+     * Current property metadata map.
      *
-     * @type {Map<PropertyName, PropertyMetadata<TType, any>>}
+     * @type {Map<PropertyName, PropertyMetadata<TObject, any>>}
      */
-    readonly propertyMetadataMap: Map<PropertyName, PropertyMetadata<TType, any>>;
+    private readonly currentPropertyMetadataMap;
     /**
-     * Injections defined for a type.
+     * Current inject metadata map.
      *
-     * @type {Map<InjectIndex, InjectMetadata<TType, any>>}
+     * @type {Map<InjectIndex, InjectMetadata<TObject, any>>}
      */
-    readonly injectMetadataMap: Map<InjectIndex, InjectMetadata<TType, any>>;
+    private readonly currentInjectMetadataMap;
     /**
-     * Parent type metadatas.
+     * Current type state.
      *
-     * @type {Array<TypeMetadata<any>>}
+     * @type {TypeState<TObject>}
      */
-    readonly parentTypeMetadatas: Array<TypeMetadata<any>>;
+    private currentTypeState;
     /**
      * Constructor.
      *
      * @param {TypeManager} typeManager Type manager.
+     * @param {Map<Alias, TypeFn<any>>} typeFnMap Type function map for types with aliases.
+     * @param {ReadonlySet<TypeMetadata<any>>} typeMetadataSet Type metadata set.
      * @param {TypeFn<any>} typeFn Type function.
-     * @param {TypeOptions<TType>} typeOptions Type options.
-     * @param {Array<TypeMetadata<any>>} parentTypeMetadatas Parent type metadatas.
+     * @param {TypeOptions<TObject>} typeOptions Type options.
+     * @param {Optional<TypeMetadata<any>>} parentTypeMetadata Parent type metadata.
      */
-    constructor(typeManager: TypeManager, typeFn: TypeFn<TType>, typeOptions: TypeOptions<TType>, parentTypeMetadatas: Array<TypeMetadata<any>>);
+    constructor(typeManager: TypeManager, typeFnMap: Map<Alias, TypeFn<any>>, typeMetadataSet: ReadonlySet<TypeMetadata<any>>, typeFn: TypeFn<TObject>, typeOptions: TypeOptions<TObject>, parentTypeMetadata: Optional<TypeMetadata<any>>);
     /**
-     * Parent type metadata.
+     * Gets type state.
      *
-     * @type {TypeMetadata<any>}
+     * @returns {TypeState<TObject>} Type state.
      */
-    get parentTypeMetadata(): TypeMetadata<any> | undefined;
+    get typeState(): TypeState<TObject>;
     /**
-     * Gets alias.
+     * Gets inject metadata map.
      *
-     * @returns {Alias|undefined} Alias or undefined.
+     * @returns {ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>}
      */
-    get alias(): Alias | undefined;
+    get injectMetadataMap(): ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>;
     /**
-     * Gets custom options.
+     * Gets property metadata map.
      *
-     * @returns {Array<CustomOption>} Custom options.
+     * @returns {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>}
      */
-    get customOptions(): Array<CustomOption> | undefined;
+    get propertyMetadataMap(): ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>;
     /**
-     * Gets custom context.
+     * Gets alias.
+     *
+     * @returns {Optional<Alias>} Alias or undefined.
+     */
+    get alias(): Optional<Alias>;
+    /**
+     * Gets custom value map.
      *
-     * @returns {CustomContext} Custom context.
+     * @returns {ReadonlyMap<CustomKey<any>, CustomValue>} Custom value map.
      */
-    get customContext(): CustomContext;
+    get customValueMap(): ReadonlyMap<CustomKey<any>, CustomValue>;
     /**
      * Gets serialized null value.
      *
-     * @returns {any|undefined} Resolved serialized null value or undefined.
+     * @returns {Nullable<any>} Resolved serialized null value.
      */
-    get serializedNullValue(): any | undefined;
+    get serializedNullValue(): Nullable<any>;
     /**
      * Gets serialized default value.
      *
-     * @returns {any|undefined} Resolved serialized default value or undefined.
+     * @returns {Optional<any>} Resolved serialized default value.
      */
-    get serializedDefaultValue(): any | undefined;
+    get serializedDefaultValue(): Optional<any>;
     /**
      * Gets deserialized null value.
      *
-     * @returns {any|undefined} Resolved deserialized null value or undefined.
+     * @returns {Nullable<any>} Resolved deserialized null value.
      */
-    get deserializedNullValue(): any | undefined;
+    get deserializedNullValue(): Nullable<any>;
     /**
      * Gets deserialized default value.
      *
-     * @returns {any|undefined} Resolved deserialized default value or undefined.
+     * @returns {Optional<any>} Resolved deserialized default value.
      */
-    get deserializedDefaultValue(): any | undefined;
+    get deserializedDefaultValue(): Optional<any>;
     /**
      * Gets discriminant.
      *
@@ -175,9 +193,9 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Gets injectable value.
      *
-     * @returns {boolean|undefined} Injectable indicator or undefined.
+     * @returns {boolean} Injectable indicator.
      */
-    get injectable(): boolean | undefined;
+    get injectable(): boolean;
     /**
      * Gets injector.
      *
@@ -185,17 +203,17 @@ export declare class TypeMetadata<TType> extends Metadata {
      */
     get injector(): Injector;
     /**
-     * Gets log.
+     * Gets logger.
      *
-     * @returns {Log} Log instance.
+     * @returns {Logger} Logger instance.
      */
-    get log(): Log;
+    get logger(): Logger;
     /**
      * Gets naming convention.
      *
-     * @returns {NamingConvention|undefined} Naming convention or undefined.
+     * @returns {Optional<NamingConvention>} Naming convention or undefined.
      */
-    get namingConvention(): NamingConvention | undefined;
+    get namingConvention(): Optional<NamingConvention>;
     /**
      * Gets indicator if current type metadata is polymorphic.
      *
@@ -217,9 +235,9 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Gets serializer.
      *
-     * @returns {Serializer<TType>} Serializer.
+     * @returns {Serializer<TObject>} Serializer.
      */
-    get serializer(): Serializer<TType>;
+    get serializer(): Serializer<TObject>;
     /**
      * Gets indicator if null value should be preserved.
      *
@@ -241,66 +259,151 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Gets property sorter.
      *
-     * @returns {PropertySorter|undefined} Property sorter or undefined.
+     * @returns {Optional<PropertySorter>} Property sorter or undefined.
      */
-    get propertySorter(): PropertySorter | undefined;
+    get propertySorter(): Optional<PropertySorter>;
     /**
      * Gets sorted property metadatas.
      *
-     * @returns {IterableIterator<PropertyMetadata<TType, any>>} Iterable of property metadatas.
+     * @returns {ReadonlyArray<PropertyMetadata<TObject, any>>} Readonly array of property metadatas.
      */
-    get sortedPropertyMetadatas(): IterableIterator<PropertyMetadata<TType, any>>;
+    get sortedPropertyMetadatas(): ReadonlyArray<PropertyMetadata<TObject, any>>;
     /**
      * Gets inject sorter.
      *
-     * @returns {InjectSorter|undefined} Property sorter or undefined.
+     * @returns {Optional<InjectSorter>} Property sorter or undefined.
      */
-    get injectSorter(): InjectSorter | undefined;
+    get injectSorter(): Optional<InjectSorter>;
     /**
      * Gets sorted inject metadatas.
      *
-     * @returns {IterableIterator<InjectMetadata<TType, any>>} Iterable of inject metadatas.
+     * @returns {ReadonlyArray<InjectMetadata<TObject, any>>} Iterable of inject metadatas.
      */
-    get sortedInjectMetadatas(): IterableIterator<InjectMetadata<TType, any>>;
+    get sortedInjectMetadatas(): ReadonlyArray<InjectMetadata<TObject, any>>;
     /**
-     * Gets property options map.
+     * Gets parent type arguments.
      *
-     * @returns {Map<PropertyName, PropertyOptions<any>>} Property options map.
+     * @returns {ReadonlyArray<TypeArgument<any>>} Parent arguments.
      */
-    get propertyOptionsMap(): Map<PropertyName, PropertyOptions<any>>;
+    get parentTypeArguments(): ReadonlyArray<TypeArgument<any>>;
     /**
-     * Gets inject options map.
+     * Gets property options map.
      *
-     * @returns {Map<InjectIndex, InjectOptions<any>>} Inject options map.
+     * @returns {ReadonlyMap<PropertyName, PropertyOptions<any>>} Property options map.
      */
-    get injectOptionsMap(): Map<InjectIndex, InjectOptions<any>>;
+    get propertyOptionsMap(): ReadonlyMap<PropertyName, PropertyOptions<any>>;
     /**
-     * Gets parent type fns value.
+     * Gets inject options map.
      *
-     * @returns {Array<TypeFn<any>>|undefined} Parent type fns or undefined.
+     * @returns {ReadonlyMap<InjectIndex, InjectOptions<any>>} Inject options map.
      */
-    get parentTypeFns(): Array<TypeFn<any>> | undefined;
+    get injectOptionsMap(): ReadonlyMap<InjectIndex, InjectOptions<any>>;
     /**
      * Constructs initial type options by extending passed options
      * with default values if they are not overriden. All references are kept.
      *
-     * @param {TypeOptions<TType>} typeOptions Type options.
+     * @param {TypeOptions<TObject>} typeOptions Type options.
      *
-     * @returns {TypeOptions<TType>} Constructed type options.
+     * @returns {TypeOptions<TObject>} Constructed type options.
      */
     private constructTypeOptions;
     /**
-     * Constructs type internals.
+     * Configures type extension metadata.
+     *
+     * @param {TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TObject>} typeExtensionMetadataCtor Type extension metadata constructor.
+     * @param {TTypeExtensionOptions} typeExtensionOptions Type extension options.
+     *
+     * @returns {TTypeExtensionMetadata} Type extension metadata
+     */
+    configureTypeExtensionMetadata<TTypeExtensionMetadata extends TypeExtensionMetadata<TObject, TTypeExtensionOptions>, TTypeExtensionOptions extends TypeExtensionOptions>(typeExtensionMetadataCtor: TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TObject>, typeExtensionOptions?: TTypeExtensionOptions): TTypeExtensionMetadata;
+    /**
+     * Extracts type extension metadata.
+     *
+     * @param {TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TObject>} typeExtensionMetadataCtor Type extension metadata constructor.
+     *
+     * @returns {Optional<TTypeExtensionMetadata>} Type extension metadata or undefined.
+     */
+    extractTypeExtensionMetadata<TTypeExtensionMetadata extends TypeExtensionMetadata<TObject, TTypeExtensionOptions>, TTypeExtensionOptions extends TypeExtensionOptions>(typeExtensionMetadataCtor: TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TObject>): Optional<TTypeExtensionMetadata>;
+    /**
+     * Extracts type extension metadata ctor set from custom value map.
+     *
+     * @returns {Set<TypeExtensionMetadataCtor<any, any, any>>} Type extension metadata ctor set.
+     */
+    private extractTypeExtensionMetadataCtorSet;
+    /**
+     * Resolves type state.
      *
-     * @returns {TypeInternals} Constructed type internals.
+     * Calling this method has side effects by recomputing type state. If you need current
+     * type state then use provided getter for that.
+     *
+     * @returns {ResolvedTypeState<TObject>} Resolved type state.
+     */
+    resolveTypeState(): ResolvedTypeState<TObject>;
+    /**
+     * Unresolves type state.
+     *
+     * Calling this method has side effects by resetting type state.
+     *
+     * @returns {UnresolvedTypeState<TObject>} Unresolved type state.
      */
-    private constructTypeInternals;
+    unresolveTypeState(): UnresolvedTypeState<TObject>;
     /**
-     * Derives parent type metadata properties.
+     * Resolves custom value map the same way as it is done for the main options.
+     *
+     * @returns {ReadonlyMap<CustomKey<any>, CustomValue>} Resolved custom value map.
+     */
+    private resolveCustomValueMap;
+    /**
+     * Resolves own parent type metadatas.
+     *
+     * @param {ReadonlyArray<TypeArgument<any>>} parentTypeArguments Resolved parent type arguments.
+     *
+     * @returns {ReadonlyArray<TypeMetadata<any>>} Resolved own parent type metadatas.
+     */
+    private resolveOwnParentTypeMetadatas;
+    /**
+     * Resolves own child type metadatas.
+     *
+     * @returns {ReadonlyArray<TypeMetadata<any>>} Resolved own child type metadatas.
+     */
+    private resolveOwnChildTypeMetadatas;
+    /**
+     * Resolves parent type metadata set for provided type metadata reflecting inheritance order where the
+     * first element is the current type metadata and the last element is the most abstract parent. This
+     * collection is used to define all properties which are declared for the provided type metadata
+     * respecting nested declarations.
+     *
+     * @param {TypeMetadata<any>} typeMetadata Type metadata.
+     * @param {Set<TypeMetadata<any>>} parentTypeMetadataSet Parent type metadata set.
+     *
+     * @returns {ReadonlySet<TypeMetadata<any>>} Parent type metadata set.
+     */
+    private resolveParentTypeMetadataSet;
+    /**
+     * Resolved child type metadata set for provided type metadata reflecting inheritance order where the
+     * first element is the current type metadata and the last element is the most specific child. This
+     * collection is used to define polymorphic relationships between types.
+     *
+     * @param {TypeMetadata<any>} typeMetadata Type metadata.
+     * @param {Set<TypeMetadata<any>>} childTypeMetadataSet Child type metadata set.
+     *
+     * @returns {ReadonlySet<TypeMetadata<any>>} Child type metadata set.
+     */
+    private resolveChildTypeMetadataSet;
+    /**
+     * Resolves property metadata map.
+     *
+     * @param {ReadonlyArray<TypeMetadata<any>>} parentTypeMetadatas Resolved parent type metadatas.
+     *
+     * @returns {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>} Resolved property metadata map.
+     */
+    private resolvePropertyMetadataMap;
+    /**
+     * Extends parent type metadata.
      *
      * @returns {this} Current instance of type metadata.
      */
-    private deriveParentTypeMetadataProperties;
+    private extendParentTypeMetadata;
     /**
      * Reflects inject metadata.
      *
@@ -312,11 +415,11 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Configures alias.
      *
-     * @param {Alias|undefined} alias Alias.
+     * @param {Optional<Alias>} alias Alias.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasAlias(alias: Alias | undefined): this;
+    hasAlias(alias: Optional<Alias>): this;
     /**
      * Releases alias.
      *
@@ -324,30 +427,38 @@ export declare class TypeMetadata<TType> extends Metadata {
      */
     private releaseAlias;
     /**
-     * Configures custom option.
+     * Configures custom value map.
+     *
+     * @param {Optional<Map<CustomKey<any>, CustomValue>>} customValueMap Custom value map or undefined.
+     *
+     * @returns {this} Current instance of type metadata.
+     */
+    hasCustomValueMap(customValueMap: Optional<Map<CustomKey<any>, CustomValue>>): this;
+    /**
+     * Configures custom value.
      *
      * @param {CustomKey<TCustomValue>} customKey Custom key.
      * @param {TCustomValue} customValue Custom value.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasCustomOption<TCustomValue>(customKey: CustomKey<TCustomValue>, customValue: TCustomValue): this;
+    hasCustomValue<TCustomValue>(customKey: CustomKey<TCustomValue>, customValue: TCustomValue): this;
     /**
-     * Extracts custom option.
+     * Extracts value by custom key.
      *
      * @param {CustomKey<TCustomValue>} customKey Custom key.
      *
      * @returns {TCustomValue} Custom value.
      */
-    extractCustomOption<TCustomValue>(customKey: CustomKey<TCustomValue>): TCustomValue;
+    extractCustomValue<TCustomValue>(customKey: CustomKey<TCustomValue>): TCustomValue;
     /**
      * Configures custom options.
      *
-     * @param {Array<CustomOption>|undefined} customOptions Custom options.
+     * @param {ReadonlyArray<CustomOption>} customOptions Custom options.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasCustomOptions(customOptions: Array<CustomOption> | undefined): this;
+    hasCustomOptions(customOptions: ReadonlyArray<CustomOption>): this;
     /**
      * Configures default value.
      *
@@ -375,36 +486,27 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Configures discriminator.
      *
-     * @param {Discriminator|undefined} discriminator Discriminator.
+     * @param {Optional<Discriminator>} discriminator Discriminator.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasDiscriminator(discriminator: Discriminator | undefined): this;
+    hasDiscriminator(discriminator: Optional<Discriminator>): this;
     /**
      * Configures discriminant.
      *
-     * @param {Discriminant|undefined} discriminant Discriminant.
+     * @param {Optional<Discriminant>} discriminant Discriminant.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasDiscriminant(discriminant: Discriminant | undefined): this;
-    /**
-     * Provides discriminant.
-     *
-     * @param {TypeFn<any>} typeFn Type function.
-     * @param {Discriminant} discriminant Discriminant.
-     *
-     * @returns {this} Current instance of type metadata.
-     */
-    private provideDiscriminant;
+    hasDiscriminant(discriminant: Optional<Discriminant>): this;
     /**
      * Configures factory.
      *
-     * @param {Factory|undefined} factory Factory.
+     * @param {Optional<Factory>} factory Factory.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasFactory(factory: Factory | undefined): this;
+    hasFactory(factory: Optional<Factory>): this;
     /**
      * Configures injectable.
      *
@@ -416,27 +518,27 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Configures injector.
      *
-     * @param {Injector|undefined} injector Injector.
+     * @param {Optional<Injector>} injector Injector.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasInjector(injector: Injector | undefined): this;
+    hasInjector(injector: Optional<Injector>): this;
     /**
-     * Configures log.
+     * Configures logger.
      *
-     * @param {Log|undefined} log Log.
+     * @param {Optional<Logger>} logger Logger.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasLog(log: Log | undefined): this;
+    hasLogger(logger: Optional<Logger>): this;
     /**
      * Configures naming convention.
      *
-     * @param {NamingConvention|undefined} namingConvention Naming convention.
+     * @param {Optional<NamingConvention>} namingConvention Naming convention.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasNamingConvention(namingConvention: NamingConvention | undefined): this;
+    hasNamingConvention(namingConvention: Optional<NamingConvention>): this;
     /**
      * Configures preserve discriminator.
      *
@@ -448,19 +550,19 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Configures reference handler.
      *
-     * @param {ReferenceHandler|undefined} referenceHandler Reference handler.
+     * @param {Optional<ReferenceHandler>} referenceHandler Reference handler.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasReferenceHandler(referenceHandler: ReferenceHandler | undefined): this;
+    hasReferenceHandler(referenceHandler: Optional<ReferenceHandler>): this;
     /**
      * Configures serializer.
      *
-     * @param {Serializer<TType>|undefined} serializer Serializer.
+     * @param {Optional<Serializer<TObject>>} serializer Serializer.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasSerializer(serializer: Serializer<TType> | undefined): this;
+    hasSerializer(serializer: Optional<Serializer<TObject>>): this;
     /**
      * Configures preserve null.
      *
@@ -488,37 +590,45 @@ export declare class TypeMetadata<TType> extends Metadata {
     /**
      * Configures property sorter.
      *
-     * @param {PropertySorter|undefined} propertySorter Property sorter.
+     * @param {Optional<PropertySorter>} propertySorter Property sorter.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasPropertySorter(propertySorter: PropertySorter | undefined): this;
+    hasPropertySorter(propertySorter: Optional<PropertySorter>): this;
     /**
      * Configures inject sorter.
      *
-     * @param {InjectSorter|undefined} injectSorter Inject sorter.
+     * @param {Optional<InjectSorter>} injectSorter Inject sorter.
      *
      * @returns {this} Current instance of type metadata.
      */
-    hasInjectSorter(injectSorter: InjectSorter | undefined): this;
+    hasInjectSorter(injectSorter: Optional<InjectSorter>): this;
+    /**
+     * Configures parent type arguments.
+     *
+     * @param {Array<TypeArgument<any>>} parentTypeArguments Parent type arguments.
+     *
+     * @returns {this} Current instance of type metadata.
+     */
+    hasParentTypeArguments(parentTypeArguments: Array<TypeArgument<any>>): this;
     /**
      * Configures certain property metadata.
      *
      * @param {PropertyName} propertyName Property name.
      * @param {PropertyOptions<TPropertyType>} propertyOptions Property options.
      *
-     * @returns {PropertyMetadata<TType, TPropertyType>} Configured property metadata.
+     * @returns {PropertyMetadata<TObject, TPropertyType>} Configured property metadata.
      */
-    configurePropertyMetadata<TPropertyType>(propertyName: PropertyName, propertyOptions?: PropertyOptions<TPropertyType>): PropertyMetadata<TType, TPropertyType>;
+    configurePropertyMetadata<TPropertyType>(propertyName: PropertyName, propertyOptions?: PropertyOptions<TPropertyType>): PropertyMetadata<TObject, TPropertyType>;
     /**
      * Configures certain inject metadata.
      *
      * @param {InjectIndex} injectIndex Inject index.
      * @param {InjectOptions<TInjectType>} injectOptions Inject options.
      *
-     * @returns {InjectMetadata<TType, TInjectType>} Configured inject metadata.
+     * @returns {InjectMetadata<TObject, TInjectType>} Configured inject metadata.
      */
-    configureInjectMetadata<TInjectType>(injectIndex: InjectIndex, injectOptions?: InjectOptions<TInjectType>): InjectMetadata<TType, TInjectType>;
+    configureInjectMetadata<TInjectType>(injectIndex: InjectIndex, injectOptions?: InjectOptions<TInjectType>): InjectMetadata<TObject, TInjectType>;
     /**
      * Configures property metadata map.
      *
@@ -528,45 +638,36 @@ export declare class TypeMetadata<TType> extends Metadata {
      */
     hasPropertyMetadataMap<TPropertyType>(propertyOptionsMap: Map<PropertyName, PropertyOptions<TPropertyType>>): this;
     /**
-     * Configures inject metadata map.
-     *
-     * @param {Map<InjectIndex, InjectOptions<TInjectType>>} injectOptionsMap Inject options map.
-     *
-     * @returns {this} Current instance of type metadata.
-     */
-    hasInjectMetadataMap<TInjectType>(injectOptionsMap: Map<InjectIndex, InjectOptions<TInjectType>>): this;
-    /**
-     * Configures type extension metadata.
+     * Clears property options map.
      *
-     * @param {TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TType>} typeExtensionMetadataCtor Type extension metadata constructor.
-     * @param {TTypeExtensionOptions} typeExtensionOptions Type extension options.
+     * @param {Map<PropertyName, PropertyOptions<TPropertyType>>} propertyOptionsMap Property options map.
      *
-     * @returns {TTypeExtensionMetadata} Type extension metadata
+     * @returns {Map<PropertyName, PropertyOptions<any>>} Cleared property options map.
      */
-    configureTypeExtensionMetadata<TTypeExtensionMetadata extends TypeExtensionMetadata<TType, TTypeExtensionOptions>, TTypeExtensionOptions extends TypeExtensionOptions>(typeExtensionMetadataCtor: TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TType>, typeExtensionOptions?: TTypeExtensionOptions): TTypeExtensionMetadata;
+    private clearPropertyOptionsMap;
     /**
-     * Extracts type extension metadata.
+     * Configures inject metadata map.
      *
-     * @param {TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TType>} typeExtensionMetadataCtor Type extension metadata constructor.
+     * @param {Map<InjectIndex, InjectOptions<TInjectType>>} injectOptionsMap Inject options map.
      *
-     * @returns {TTypeExtensionMetadata|undefined} Type extension metadata or undefined.
+     * @returns {this} Current instance of type metadata.
      */
-    extractTypeExtensionMetadata<TTypeExtensionMetadata extends TypeExtensionMetadata<TType, TTypeExtensionOptions>, TTypeExtensionOptions extends TypeExtensionOptions>(typeExtensionMetadataCtor: TypeExtensionMetadataCtor<TTypeExtensionMetadata, TTypeExtensionOptions, TType>): TTypeExtensionMetadata | undefined;
+    hasInjectMetadataMap<TInjectType>(injectOptionsMap: Map<InjectIndex, InjectOptions<TInjectType>>): this;
     /**
-     * Configures parent type fns.
+     * Clears inject options map.
      *
-     * @param {Array<TypeFn<any>>} parentTypeFns Parent type fns.
+     * @param {Map<InjectIndex, InjectOptions<TInjectType>>} injectOptionsMap Inject options map.
      *
-     * @returns {this} Current instance of type metadata.
+     * @returns {Map<InjectIndex, InjectOptions<any>>} Cleared inject options map.
      */
-    hasParentTypeFns(parentTypeFns: Array<TypeFn<any>>): this;
+    private clearInjectOptionsMap;
     /**
      * Configures type metadata based on provided options.
      *
-     * @param {TypeOptions<TType>} typeOptions Type options.
+     * @param {TypeOptions<TObject>} typeOptions Type options.
      *
      * @returns {this} Current instance of type metadata.
      */
-    configure(typeOptions: TypeOptions<TType>): this;
+    configure(typeOptions: TypeOptions<TObject>): this;
 }
 //# sourceMappingURL=type-metadata.d.ts.map