import { ClassType } from "../../type";
import { ModuleConfig } from "./ModuleConfig";
import { InjectionToken } from "../..";
/**
 * Data object which holds raw information collected for particular Type from class metadataInternal decorators.
 * This is internal class of metadataInternal package and should never be used outside of it.
 */
export declare class TypeMetadataInternal {
    readonly type: ClassType;
    private _constructorArguments;
    private _optionalConstructorArguments;
    private _propertyInjections;
    private _optionalPropertyInjections;
    private _postConstructMethods;
    private _preDestroyMethods;
    private _moduleDescriptor;
    /**
     * Create new instance
     * @param type Type of class prototype this instance holds metadataInternal for
     */
    constructor(type: ClassType);
    /**
     * List of type constructor arguments data types
     */
    get constructorArguments(): ReadonlyArray<ClassType>;
    /**
     * Indices of injectable constructor arguments that are optional and should be omitted, in case if there is no
     * mapping found in Injector, with no error.
     */
    get optionalConstructorArguments(): ReadonlySet<number>;
    /**
     * List of type property name and data type pairs that should be filled with values from Injector as instance
     * of this type is created.
     */
    get propertyInjections(): ReadonlyMap<string, ClassType | InjectionToken>;
    /**
     * List of optional property injections.
     */
    get optionalPropertyInjections(): ReadonlySet<string>;
    /**
     * List of method names that should be invoked as new instance of type is created and all injection points have
     * got values
     */
    get postConstructMethods(): ReadonlySet<string>;
    /**
     * List of method names that should be invoked as Injected properties are applied to new created class.
     */
    get preDestroyMethods(): ReadonlySet<string>;
    /**
     * Module descriptor object that marks type as a module and defines properties of a module entry.
     */
    get moduleDescriptor(): ModuleConfig;
    setConstructorArguments(value: ClassType[]): void;
    setOptionalConstructorArgument(index: number): void;
    addPropertyInjection(name: string, type: ClassType | InjectionToken): void;
    setOptionalPropertyInjection(name: string): void;
    addPostConstructMethod(name: string): void;
    addPreDestroyMethod(name: string): void;
    setModuleDescriptor(descriptor: ModuleConfig): void;
}