@dipscope/type-manager/dist/types/type-metadata.d.ts

Transform JSON strings or plain objects into JS class instances.

import { Alias } from './alias';
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';
import { Factory } from './factory';
import { InjectIndex } from './inject-index';
import { InjectMetadata } from './inject-metadata';
import { InjectOptions } from './inject-options';
import { InjectSorter } from './inject-sorter';
import { Injector } from './injector';
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 { SerializerCallback } from './serializer-callback';
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 { TypeManager } from './type-manager';
import { TypeName } from './type-name';
import { TypeOptions } from './type-options';
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<TObject>}
 */
export declare class TypeMetadata<TObject> extends Metadata {
    /**
     * Type name.
     *
     * Defined at runtime based on the constructor function.
     *
     * @type {TypeName}
     */
    readonly typeName: TypeName;
    /**
     * Type function.
     *
     * @type {TypeFn<TObject>}
     */
    readonly typeFn: TypeFn<TObject>;
    /**
     * Parent type metadata.
     *
     * @type {Optional<TypeMetadata<any>>}
     */
    readonly parentTypeMetadata: Optional<TypeMetadata<any>>;
    /**
     * Type options used as a fallback.
     *
     * @type {TypeOptionsBase<TObject>}
     */
    private readonly typeOptionsBase;
    /**
     * Type options.
     *
     * @type {TypeOptions<TObject>}
     */
    private readonly typeOptions;
    /**
     * Type metadata set.
     *
     * @type {ReadonlySet<TypeMetadata<any>>}
     */
    private readonly typeMetadataSet;
    /**
     * Current type function map.
     *
     * @type {Map<Alias, TypeFn<any>>}
     */
    private readonly currentTypeFnMap;
    /**
     * Current child type metadata map.
     *
     * @type {Map<TypeFn<TObject>, TypeMetadata<any>>}
     */
    private readonly currentChildTypeMetadataMap;
    /**
     * Current property metadata map.
     *
     * @type {Map<PropertyName, PropertyMetadata<TObject, any>>}
     */
    private readonly currentPropertyMetadataMap;
    /**
     * Current inject metadata map.
     *
     * @type {Map<InjectIndex, InjectMetadata<TObject, any>>}
     */
    private readonly currentInjectMetadataMap;
    /**
     * Current type state.
     *
     * @type {TypeState<TObject>}
     */
    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<TObject>} typeOptions Type options.
     * @param {Optional<TypeMetadata<any>>} parentTypeMetadata Parent type metadata.
     */
    constructor(typeManager: TypeManager, typeFnMap: Map<Alias, TypeFn<any>>, typeMetadataSet: ReadonlySet<TypeMetadata<any>>, typeFn: TypeFn<TObject>, typeOptions: TypeOptions<TObject>, parentTypeMetadata: Optional<TypeMetadata<any>>);
    /**
     * Gets type state.
     *
     * @returns {TypeState<TObject>} Type state.
     */
    get typeState(): TypeState<TObject>;
    /**
     * Gets inject metadata map.
     *
     * @returns {ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>}
     */
    get injectMetadataMap(): ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>;
    /**
     * Gets property metadata map.
     *
     * @returns {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>}
     */
    get propertyMetadataMap(): ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>;
    /**
     * Gets alias.
     *
     * @returns {Optional<Alias>} Alias or undefined.
     */
    get alias(): Optional<Alias>;
    /**
     * Gets custom value map.
     *
     * @returns {ReadonlyMap<CustomKey<any>, CustomValue>} Custom value map.
     */
    get customValueMap(): ReadonlyMap<CustomKey<any>, CustomValue>;
    /**
     * Gets serialized null value.
     *
     * @returns {Nullable<any>} Resolved serialized null value.
     */
    get serializedNullValue(): Nullable<any>;
    /**
     * Gets serialized default value.
     *
     * @returns {Optional<any>} Resolved serialized default value.
     */
    get serializedDefaultValue(): Optional<any>;
    /**
     * Gets deserialized null value.
     *
     * @returns {Nullable<any>} Resolved deserialized null value.
     */
    get deserializedNullValue(): Nullable<any>;
    /**
     * Gets deserialized default value.
     *
     * @returns {Optional<any>} Resolved deserialized default value.
     */
    get deserializedDefaultValue(): Optional<any>;
    /**
     * Gets before serialize callback.
     *
     * @returns {Optional<SerializerCallback<TObject>>} Before serialize callback.
     */
    get beforeSerializeCallback(): Optional<SerializerCallback<TObject>>;
    /**
     * Gets after deserialize callback.
     *
     * @returns {Optional<SerializerCallback<TObject>>} After deserialize callback.
     */
    get afterDeserializeCallback(): Optional<SerializerCallback<TObject>>;
    /**
     * Gets discriminant.
     *
     * @returns {Discriminant} Discriminant.
     */
    get discriminant(): Discriminant;
    /**
     * Gets discriminator.
     *
     * @returns {Discriminator} Discriminator.
     */
    get discriminator(): Discriminator;
    /**
     * Gets factory.
     *
     * @returns {Factory} Factory.
     */
    get factory(): Factory;
    /**
     * Gets injectable value.
     *
     * @returns {boolean} Injectable indicator.
     */
    get injectable(): boolean;
    /**
     * Gets injector.
     *
     * @returns {Injector} Injector.
     */
    get injector(): Injector;
    /**
     * Gets logger.
     *
     * @returns {Logger} Logger instance.
     */
    get logger(): Logger;
    /**
     * Gets naming convention.
     *
     * @returns {Optional<NamingConvention>} Naming convention or undefined.
     */
    get namingConvention(): Optional<NamingConvention>;
    /**
     * Gets indicator if current type metadata is polymorphic.
     *
     * @returns {boolean} True when type metadata is polymorphic. False otherwise.
     */
    get polymorphic(): boolean;
    /**
     * Gets indicator if discriminator should be preserved.
     *
     * @returns {boolean} True when discriminator should be preserved. False otherwise.
     */
    get preserveDiscriminator(): boolean;
    /**
     * Gets reference handler.
     *
     * @returns {ReferenceHandler} Reference handler.
     */
    get referenceHandler(): ReferenceHandler;
    /**
     * Gets serializer.
     *
     * @returns {Serializer<TObject>} Serializer.
     */
    get serializer(): Serializer<TObject>;
    /**
     * Gets indicator if null value should be preserved.
     *
     * @returns {boolean} True when null value should be preserved. False otherwise.
     */
    get preserveNull(): boolean;
    /**
     * Gets indicator if default value should be used.
     *
     * @returns {boolean} True when type should use default value. False otherwise.
     */
    get useDefaultValue(): boolean;
    /**
     * Gets indicator if implicit conversion should be used.
     *
     * @returns {boolean} True when type should use implicit conversion. False otherwise.
     */
    get useImplicitConversion(): boolean;
    /**
     * Gets property sorter.
     *
     * @returns {Optional<PropertySorter>} Property sorter or undefined.
     */
    get propertySorter(): Optional<PropertySorter>;
    /**
     * Gets sorted property metadatas.
     *
     * @returns {ReadonlyArray<PropertyMetadata<TObject, any>>} Readonly array of property metadatas.
     */
    get sortedPropertyMetadatas(): ReadonlyArray<PropertyMetadata<TObject, any>>;
    /**
     * Gets inject sorter.
     *
     * @returns {Optional<InjectSorter>} Property sorter or undefined.
     */
    get injectSorter(): Optional<InjectSorter>;
    /**
     * Gets sorted inject metadatas.
     *
     * @returns {ReadonlyArray<InjectMetadata<TObject, any>>} Iterable of inject metadatas.
     */
    get sortedInjectMetadatas(): ReadonlyArray<InjectMetadata<TObject, any>>;
    /**
     * Gets parent type arguments.
     *
     * @returns {ReadonlyArray<TypeArgument<any>>} Parent arguments.
     */
    get parentTypeArguments(): ReadonlyArray<TypeArgument<any>>;
    /**
     * Gets property options map.
     *
     * @returns {ReadonlyMap<PropertyName, PropertyOptions<any>>} Property options map.
     */
    get propertyOptionsMap(): ReadonlyMap<PropertyName, PropertyOptions<any>>;
    /**
     * Gets inject options map.
     *
     * @returns {ReadonlyMap<InjectIndex, InjectOptions<any>>} Inject options map.
     */
    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<TObject>} typeOptions Type options.
     *
     * @returns {TypeOptions<TObject>} Constructed type options.
     */
    private constructTypeOptions;
    /**
     * 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.
     *
     * 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.
     */
    unresolveTypeState(): UnresolvedTypeState<TObject>;
    /**
     * 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 extendParentTypeMetadata;
    /**
     * Reflects inject metadata.
     *
     * Used to configure inject metadata based on reflect metadata as inject decorators may be omitted.
     *
     * @returns {this} Current instance of type metadata.
     */
    reflectInjectMetadata(): this;
    /**
     * Configures alias.
     *
     * @param {Optional<Alias>} alias Alias.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasAlias(alias: Optional<Alias>): this;
    /**
     * Releases alias.
     *
     * @returns {this} Current instance of type metadata.
     */
    private releaseAlias;
    /**
     * 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.
     */
    hasCustomValue<TCustomValue>(customKey: CustomKey<TCustomValue>, customValue: TCustomValue): this;
    /**
     * Extracts value by custom key.
     *
     * @param {CustomKey<TCustomValue>} customKey Custom key.
     *
     * @returns {TCustomValue} Custom value.
     */
    extractCustomValue<TCustomValue>(customKey: CustomKey<TCustomValue>): TCustomValue;
    /**
     * Configures custom options.
     *
     * @param {ReadonlyArray<CustomOption>} customOptions Custom options.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasCustomOptions(customOptions: ReadonlyArray<CustomOption>): this;
    /**
     * Configures default value.
     *
     * @param {DefaultValue} defaultValue Default value.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasDefaultValue(defaultValue: DefaultValue): this;
    /**
     * Configures serialized default value.
     *
     * @param {DefaultValue} serializedDefaultValue Serialized default value.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasSerializedDefaultValue(serializedDefaultValue: DefaultValue): this;
    /**
     * Configures deserialized default value.
     *
     * @param {DefaultValue} deserializedDefaultValue Deserialized default value.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasDeserializedDefaultValue(deserializedDefaultValue: DefaultValue): this;
    /**
     * Configures before serialize callback.
     *
     * @param {Optional<SerializerCallback<TObject>>} beforeSerializeCallback Before serialize callback.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasBeforeSerializeCallback(beforeSerializeCallback: Optional<SerializerCallback<TObject>>): this;
    /**
     * Configures after deserialize callback.
     *
     * @param {Optional<SerializerCallback<TObject>>} afterDeserializeCallback After deserialize callback.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasAfterDeserializeCallback(afterDeserializeCallback: Optional<SerializerCallback<TObject>>): this;
    /**
     * Configures discriminator.
     *
     * @param {Optional<Discriminator>} discriminator Discriminator.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasDiscriminator(discriminator: Optional<Discriminator>): this;
    /**
     * Configures discriminant.
     *
     * @param {Optional<Discriminant>} discriminant Discriminant.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasDiscriminant(discriminant: Optional<Discriminant>): this;
    /**
     * Configures factory.
     *
     * @param {Optional<Factory>} factory Factory.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasFactory(factory: Optional<Factory>): this;
    /**
     * Configures injectable.
     *
     * @param {boolean} injectable Injectable.
     *
     * @returns {this} Current instance of type metadata.
     */
    isInjectable(injectable?: boolean): this;
    /**
     * Configures injector.
     *
     * @param {Optional<Injector>} injector Injector.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasInjector(injector: Optional<Injector>): this;
    /**
     * Configures logger.
     *
     * @param {Optional<Logger>} logger Logger.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasLogger(logger: Optional<Logger>): this;
    /**
     * Configures naming convention.
     *
     * @param {Optional<NamingConvention>} namingConvention Naming convention.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasNamingConvention(namingConvention: Optional<NamingConvention>): this;
    /**
     * Configures preserve discriminator.
     *
     * @param {boolean} preserveDiscriminator Preserve discriminator.
     *
     * @returns {this} Current instance of type metadata.
     */
    shouldPreserveDiscriminator(preserveDiscriminator?: boolean): this;
    /**
     * Configures reference handler.
     *
     * @param {Optional<ReferenceHandler>} referenceHandler Reference handler.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasReferenceHandler(referenceHandler: Optional<ReferenceHandler>): this;
    /**
     * Configures serializer.
     *
     * @param {Optional<Serializer<TObject>>} serializer Serializer.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasSerializer(serializer: Optional<Serializer<TObject>>): this;
    /**
     * Configures preserve null.
     *
     * @param {boolean} preserveNull Preserve null.
     *
     * @returns {this} Current instance of type metadata.
     */
    shouldPreserveNull(preserveNull?: boolean): this;
    /**
     * Configures use default value.
     *
     * @param {boolean} useDefaultValue Use default value.
     *
     * @returns {this} Current instance of type metadata.
     */
    shouldUseDefaultValue(useDefaultValue?: boolean): this;
    /**
     * Configures use implicit convertion.
     *
     * @param {boolean} useImplicitConversion Use implicit convertion.
     *
     * @returns {this} Current instance of type metadata.
     */
    shouldUseImplicitConversion(useImplicitConversion?: boolean): this;
    /**
     * Configures property sorter.
     *
     * @param {Optional<PropertySorter>} propertySorter Property sorter.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasPropertySorter(propertySorter: Optional<PropertySorter>): this;
    /**
     * Configures inject sorter.
     *
     * @param {Optional<InjectSorter>} injectSorter Inject sorter.
     *
     * @returns {this} Current instance of type metadata.
     */
    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<TObject, TPropertyType>} Configured property metadata.
     */
    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<TObject, TInjectType>} Configured inject metadata.
     */
    configureInjectMetadata<TInjectType>(injectIndex: InjectIndex, injectOptions?: InjectOptions<TInjectType>): InjectMetadata<TObject, TInjectType>;
    /**
     * Configures property metadata map.
     *
     * @param {Map<PropertyName, PropertyOptions<TPropertyType>>} propertyOptionsMap Property options map.
     *
     * @returns {this} Current instance of type metadata.
     */
    hasPropertyMetadataMap<TPropertyType>(propertyOptionsMap: Map<PropertyName, PropertyOptions<TPropertyType>>): this;
    /**
     * Clears property options map.
     *
     * @param {Map<PropertyName, PropertyOptions<TPropertyType>>} propertyOptionsMap Property options map.
     *
     * @returns {Map<PropertyName, PropertyOptions<any>>} Cleared property options map.
     */
    private clearPropertyOptionsMap;
    /**
     * 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;
    /**
     * Clears inject options map.
     *
     * @param {Map<InjectIndex, InjectOptions<TInjectType>>} injectOptionsMap Inject options map.
     *
     * @returns {Map<InjectIndex, InjectOptions<any>>} Cleared inject options map.
     */
    private clearInjectOptionsMap;
    /**
     * Configures type metadata based on provided options.
     *
     * @param {TypeOptions<TObject>} typeOptions Type options.
     *
     * @returns {this} Current instance of type metadata.
     */
    configure(typeOptions: TypeOptions<TObject>): this;
}
//# sourceMappingURL=type-metadata.d.ts.map