import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime, ServiceContainer } from "./interfaces";
import { MapOf } from "../interfaces";
export interface ActivationContextInfo {
    name: string;
    service: string;
}
/** This class is created once per `Container.resolve` method call and used to
 * cache dependencies and to track created instances. The activation context
 * tracks services with `context` activation type.
 */
export declare class ActivationContext<S extends object> {
    _cache: MapOf<any>;
    _services: ContainerServiceMap<S>;
    _visited: MapOf<any>;
    _name: string;
    _service: Descriptor<S, any>;
    _container: ServiceContainer<S>;
    _parent: ActivationContext<S> | undefined;
    /** Creates a new activation context with the specified parameters.
     * @param container the container which starts the activation process
     * @param services the initial service registrations
     * @param name the name of the service being activated, this parameter is
     *  used for the debug purpose.
     * @param service the service to activate, this parameter is used for the
     *  debug purpose.
     */
    constructor(container: ServiceContainer<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>);
    /** the name of the current resolving dependency */
    getName(): string;
    /** Returns the container for which 'resolve' method was called */
    getContainer(): ServiceContainer<S>;
    /** Resolves the specified dependency in the current context
     * @param name The name of the dependency being resolved
     */
    resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
    /** Resolves the specified dependency with the specified default value if
     * the dependency is missing.
     *
     * @param name The name of the dependency being resolved
     * @param def A default value to return in case of the specified dependency
     *   is missing.
     */
    resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
    /** Resolves the specified dependency and returns undefined in case if the
     * dependency is missing.
     *
     * @param name The name of the dependency being resolved
     */
    resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
    /**
     * registers services local to the the activation context
     *
     * @name{string} the name of the service
     * @service{string} the service descriptor to register
     */
    register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): void;
    createLifetime(): ILifetime;
    activate<T>(d: Descriptor<S, T>, name: string): T;
    visit(id: string): any;
    getStack(): ActivationContextInfo[];
    private enter;
    /** Creates a clone for the current context, used to protect it from modifications */
    clone(): this;
}