import { Binding as BindingInterface, ServiceIdentifier, Newable, BindingScope, BindingType, FactoryCreator, ProviderCreator, ContainerModuleBase, DynamicValue, ConstraintFunction, BindingActivation, BindingDeactivation } from '../interfaces/interfaces';
export declare class Binding<T> implements BindingInterface<T> {
    id: number;
    moduleId: ContainerModuleBase['id'];
    /**
     * Determines weather the bindings has been already activated
     * The activation action takes place when an instance is resolved
     * If the scope is singleton it only happens once
     */
    activated: boolean;
    /**
     * A runtime identifier because at runtime we don't have interfaces
     */
    serviceIdentifier: ServiceIdentifier<T>;
    /**
     * The constructor of a class which must implement T
     */
    implementationType: Newable<T> | T | null;
    /**
     * Cache used to allow singleton scope and BindingType.ConstantValue bindings
     */
    cache: T | null | Promise<T>;
    /**
     * Cache used to allow BindingType.DynamicValue bindings
     */
    dynamicValue: DynamicValue<T> | null;
    /**
     * The scope mode to be used
     */
    scope: BindingScope;
    /**
     * The kind of binding
     */
    type: BindingType;
    /**
     * A factory method used in BindingType.Factory bindings
     */
    factory: FactoryCreator<unknown> | null;
    /**
     * An async factory method used in BindingType.Provider bindings
     */
    provider: ProviderCreator<unknown> | null;
    /**
     * A constraint used to limit the contexts in which this binding is applicable
     */
    constraint: ConstraintFunction;
    /**
     * On activation handler (invoked just before an instance is added to cache and injected)
     */
    onActivation: BindingActivation<T> | null;
    onDeactivation: BindingDeactivation<T> | null;
    constructor(serviceIdentifier: ServiceIdentifier<T>, scope: BindingScope);
    clone(): Binding<T>;
}