@dipscope/type-manager/dist/types/type-states/resolved-type-state.d.ts

Transform JSON strings or plain objects into JS class instances.

import { Alias } from '../alias';
import { CustomKey } from '../custom-key';
import { CustomValue } from '../custom-value';
import { DefaultValue } from '../default-value';
import { DefaultValueResolver } from '../default-value-resolver';
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 { NamingConvention } from '../naming-convention';
import { NullValueResolver } from '../null-value-resolver';
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 { TypeFn } from '../type-fn';
import { TypeMetadata } from '../type-metadata';
import { TypeState } from '../type-state';
/**
 * Represents resolved type state.
 *
 * @type {ResolvedTypeState<TObject>}
 */
export declare class ResolvedTypeState<TObject> implements TypeState<TObject> {
    /**
     * Type metadata for which state is defined.
     *
     * @type {TypeMetadata<TObject>}
     */
    readonly typeMetadata: TypeMetadata<TObject>;
    /**
     * Alias.
     *
     * @type {Optional<Alias>}
     */
    readonly alias: Optional<Alias>;
    /**
     * Custom value map.
     *
     * @type {ReadonlyMap<CustomKey<any>, CustomValue>}
     */
    readonly customValueMap: ReadonlyMap<CustomKey<any>, CustomValue>;
    /**
     * Serialized null value resolver.
     *
     * @type {NullValueResolver}
     */
    readonly serializedNullValueResolver: NullValueResolver;
    /**
     * Serialized default value.
     *
     * @type {DefaultValue}
     */
    readonly serializedDefaultValue: DefaultValue;
    /**
     * Serialized default value resolver.
     *
     * @type {DefaultValueResolver}
     */
    readonly serializedDefaultValueResolver: DefaultValueResolver;
    /**
     * Deserialized null value resolver.
     *
     * @type {NullValueResolver}
     */
    readonly deserializedNullValueResolver: NullValueResolver;
    /**
     * Deserialized default value.
     *
     * @type {DefaultValue}
     */
    readonly deserializedDefaultValue: DefaultValue;
    /**
     * Deserialized default value resolver.
     *
     * @type {DefaultValueResolver}
     */
    readonly deserializedDefaultValueResolver: DefaultValueResolver;
    /**
     * Serializer callback function to call before the serialization is started.
     * Can be an instance method name or a handler for which instance is provided.
     *
     * @type {Optional<SerializerCallback<TObject>>}
     */
    readonly beforeSerializeCallback: Optional<SerializerCallback<TObject>>;
    /**
     * Serializer callback function to call after the deserialization is completed.
     * Can be an instance method name or a handler for which instance is provided.
     *
     * @type {Optional<SerializerCallback<TObject>>}
     */
    readonly afterDeserializeCallback: Optional<SerializerCallback<TObject>>;
    /**
     * Discriminant.
     *
     * @type {Discriminant}
     */
    readonly discriminant: Discriminant;
    /**
     * Discriminator.
     *
     * @type {Discriminator}
     */
    readonly discriminator: Discriminator;
    /**
     * Factory.
     *
     * @type {Factory}
     */
    readonly factory: Factory;
    /**
     * Injectable value.
     *
     * @type {Factory}
     */
    readonly injectable: boolean;
    /**
     * Injector.
     *
     * @type {Injector}
     */
    readonly injector: Injector;
    /**
     * Logger.
     *
     * @type {Logger}
     */
    readonly logger: Logger;
    /**
     * Naming convention.
     *
     * @type {Optional<NamingConvention>}
     */
    readonly namingConvention: Optional<NamingConvention>;
    /**
     * Indicator if current type metadata is polymorphic.
     *
     * @type {boolean}
     */
    readonly polymorphic: boolean;
    /**
     * Type metadata map.
     *
     * @type {ReadonlyMap<TypeFn<any>, TypeMetadata<any>>}
     */
    readonly typeMetadataMap: ReadonlyMap<TypeFn<any>, TypeMetadata<any>>;
    /**
     * Indicator if discriminator should be preserved.
     *
     * @type {boolean}
     */
    readonly preserveDiscriminator: boolean;
    /**
     * Reference handler.
     *
     * @type {ReferenceHandler}
     */
    readonly referenceHandler: ReferenceHandler;
    /**
     * Serializer.
     *
     * @type {Serializer<TObject>}
     */
    readonly serializer: Serializer<TObject>;
    /**
     * Indicator if null value should be preserved.
     *
     * @type {boolean}
     */
    readonly preserveNull: boolean;
    /**
     * Indicator if default value should be used.
     *
     * @type {boolean}
     */
    readonly useDefaultValue: boolean;
    /**
     * Indicator if implicit conversion should be used.
     *
     * @type {boolean}
     */
    readonly useImplicitConversion: boolean;
    /**
     * Property sorter.
     *
     * @type {Optional<PropertySorter>}
     */
    readonly propertySorter: Optional<PropertySorter>;
    /**
     * Sorted property metadatas.
     *
     * @type {ReadonlyArray<PropertyMetadata<TObject, any>>}
     */
    readonly sortedPropertyMetadatas: ReadonlyArray<PropertyMetadata<TObject, any>>;
    /**
     * Inject sorter.
     *
     * @type {Optional<InjectSorter>}
     */
    readonly injectSorter: Optional<InjectSorter>;
    /**
     * Sorted inject metadatas.
     *
     * @type {ReadonlyArray<InjectMetadata<TObject, any>>}
     */
    readonly sortedInjectMetadatas: ReadonlyArray<InjectMetadata<TObject, any>>;
    /**
     * Parent type arguments.
     *
     * @type {ReadonlyArray<TypeArgument<any>>}
     */
    readonly parentTypeArguments: ReadonlyArray<TypeArgument<any>>;
    /**
     * Parent type metadatas.
     *
     * @type {ReadonlyArray<TypeMetadata<any>>}
     */
    readonly parentTypeMetadatas: ReadonlyArray<TypeMetadata<any>>;
    /**
     * Own parent type metadatas.
     *
     * @type {ReadonlyArray<TypeMetadata<any>>}
     */
    readonly ownParentTypeMetadatas: ReadonlyArray<TypeMetadata<any>>;
    /**
     * Child type metadatas.
     *
     * @type {ReadonlyArray<TypeMetadata<any>>}
     */
    readonly childTypeMetadatas: ReadonlyArray<TypeMetadata<any>>;
    /**
     * Own child type metadatas.
     *
     * @type {ReadonlyArray<TypeMetadata<any>>}
     */
    readonly ownChildTypeMetadatas: ReadonlyArray<TypeMetadata<any>>;
    /**
     * Property options map.
     *
     * @type {ReadonlyMap<PropertyName, PropertyOptions<any>>}
     */
    readonly propertyOptionsMap: ReadonlyMap<PropertyName, PropertyOptions<any>>;
    /**
     * Property metadata map.
     *
     * @type {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>}
     */
    readonly propertyMetadataMap: ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>;
    /**
     * Own property metadata map.
     *
     * @type {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>}
     */
    readonly ownPropertyMetadataMap: ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>;
    /**
     * Inject options map.
     *
     * @type {ReadonlyMap<InjectIndex, PropertyOptions<any>>}
     */
    readonly injectOptionsMap: ReadonlyMap<InjectIndex, InjectOptions<any>>;
    /**
     * Inject metadata map.
     *
     * @type {ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>}
     */
    readonly injectMetadataMap: ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>;
    /**
     * Constructor.
     *
     * @param {TypeMetadata<TObject>} typeMetadata Type metadata for which state is defined.
     * @param {Optional<Alias>} alias Alias.
     * @param {ReadonlyMap<CustomKey<any>, CustomValue>} customValueMap Custom value map.
     * @param {NullValueResolver} serializedNullValueResolver Serialized null value resolver.
     * @param {DefaultValue} serializedDefaultValue Serialized default value.
     * @param {DefaultValueResolver} serializedDefaultValueResolver Serialized default value resolver.
     * @param {NullValueResolver} deserializedNullValueResolver Deserialized null value resolver.
     * @param {DefaultValue} deserializedDefaultValue Deserialized default value.
     * @param {DefaultValueResolver} deserializedDefaultValueResolver Deserialized default value resolver.
     * @param {Discriminant} discriminant Discriminant.
     * @param {Discriminator} discriminator Discriminator.
     * @param {Optional<SerializerCallback<TObject>>} beforeSerializeCallback Before serialize callback.
     * @param {Optional<SerializerCallback<TObject>>} afterDeserializeCallback After deserialize callback.
     * @param {Factory} factory Factory.
     * @param {boolean} injectable Injectable value.
     * @param {Injector} injector Injector.
     * @param {Logger} logger Logger.
     * @param {Optional<NamingConvention>} namingConvention Naming convention.
     * @param {boolean} polymorphic Indicator if current type metadata is polymorphic.
     * @param {ReadonlyMap<TypeFn<any>, TypeMetadata<any>>} typeMetadataMap Type metadata map.
     * @param {boolean} preserveDiscriminator Indicator if discriminator should be preserved.
     * @param {ReferenceHandler} referenceHandler Reference handler.
     * @param {Serializer<TObject>} serializer Serializer.
     * @param {boolean} preserveNull Indicator if null value should be preserved.
     * @param {boolean} useDefaultValue Indicator if default value should be used.
     * @param {boolean} useImplicitConversion Indicator if implicit conversion should be used.
     * @param {Optional<PropertySorter>} propertySorter Property sorter.
     * @param {ReadonlyArray<PropertyMetadata<TObject, any>>} sortedPropertyMetadatas Sorted property metadatas.
     * @param {Optional<InjectSorter>} injectSorter Inject sorter.
     * @param {ReadonlyArray<InjectMetadata<TObject, any>>} sortedInjectMetadatas Sorted inject metadatas.
     * @param {ReadonlyArray<TypeArgument<any>>} parentTypeArguments Parent type arguments.
     * @param {ReadonlyArray<TypeMetadata<any>>} parentTypeMetadatas Parent type metadatas.
     * @param {ReadonlyArray<TypeMetadata<any>>} ownParentTypeMetadatas Own parent type metadatas.
     * @param {ReadonlyArray<TypeMetadata<any>>} childTypeMetadatas Child type metadatas.
     * @param {ReadonlyArray<TypeMetadata<any>>} ownChildTypeMetadatas Own child type metadatas.
     * @param {ReadonlyMap<PropertyName, PropertyOptions<any>>} propertyOptionsMap Property options map.
     * @param {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>} propertyMetadataMap Property metadata map.
     * @param {ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>} ownPropertyMetadataMap Own property metadata map.
     * @param {ReadonlyMap<InjectIndex, PropertyOptions<any>>} injectOptionsMap Inject options map.
     * @param {ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>} injectMetadataMap Inject metadata map.
     */
    constructor(typeMetadata: TypeMetadata<TObject>, alias: Optional<Alias>, customValueMap: ReadonlyMap<CustomKey<any>, CustomValue>, serializedNullValueResolver: NullValueResolver, serializedDefaultValue: DefaultValue, serializedDefaultValueResolver: DefaultValueResolver, deserializedNullValueResolver: NullValueResolver, deserializedDefaultValue: DefaultValue, deserializedDefaultValueResolver: DefaultValueResolver, beforeSerializeCallback: Optional<SerializerCallback<TObject>>, afterDeserializeCallback: Optional<SerializerCallback<TObject>>, discriminant: Discriminant, discriminator: Discriminator, factory: Factory, injectable: boolean, injector: Injector, logger: Logger, namingConvention: Optional<NamingConvention>, polymorphic: boolean, typeMetadataMap: ReadonlyMap<TypeFn<any>, TypeMetadata<any>>, preserveDiscriminator: boolean, referenceHandler: ReferenceHandler, serializer: Serializer<TObject>, preserveNull: boolean, useDefaultValue: boolean, useImplicitConversion: boolean, propertySorter: Optional<PropertySorter>, sortedPropertyMetadatas: ReadonlyArray<PropertyMetadata<TObject, any>>, injectSorter: Optional<InjectSorter>, sortedInjectMetadatas: ReadonlyArray<InjectMetadata<TObject, any>>, parentTypeArguments: ReadonlyArray<TypeArgument<any>>, parentTypeMetadatas: ReadonlyArray<TypeMetadata<any>>, ownParentTypeMetadatas: ReadonlyArray<TypeMetadata<any>>, childTypeMetadatas: ReadonlyArray<TypeMetadata<any>>, ownChildTypeMetadatas: ReadonlyArray<TypeMetadata<any>>, propertyOptionsMap: ReadonlyMap<PropertyName, PropertyOptions<any>>, propertyMetadataMap: ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>, ownPropertyMetadataMap: ReadonlyMap<PropertyName, PropertyMetadata<TObject, any>>, injectOptionsMap: ReadonlyMap<InjectIndex, PropertyOptions<any>>, injectMetadataMap: ReadonlyMap<InjectIndex, InjectMetadata<TObject, any>>);
}
//# sourceMappingURL=resolved-type-state.d.ts.map