import { ServiceIdentifier, Provider, ProviderScope } from './types';
export interface InjectorOptions {
    name?: string;
    injectorScope?: ProviderScope;
    defaultProviderScope?: ProviderScope;
    hooks?: string[];
    initialProviders?: Provider[];
    children?: Injector[];
}
export declare class Injector<Session extends object = any> {
    private options;
    private _classMap;
    private _factoryMap;
    private _applicationScopeInstanceMap;
    private _sessionScopeInstanceMap;
    private _applicationScopeServiceIdentifiers;
    private _requestScopeServiceIdentifiers;
    private _sessionScopeServiceIdentifiers;
    private _hookServiceIdentifiersMap;
    private _name;
    private _injectorScope;
    private _defaultProviderScope;
    private _hooks;
    private _initialProviders;
    private _children;
    onInstanceCreated: <T>(arg?: {
        serviceIdentifier: ServiceIdentifier<T>;
        instance: T;
    }) => any;
    constructor(options?: InjectorOptions);
    addChild(...children: Injector[]): void;
    removeChild(...children: Injector[]): void;
    hasChild(child: Injector): boolean;
    private getScopeInstanceMap;
    provide<T>(provider: Provider<T>): void;
    has<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
    remove<T>(serviceIdentifier: ServiceIdentifier<T>): void;
    get scopeServiceIdentifiers(): ServiceIdentifier<any>[];
    get<T>(serviceIdentifier: ServiceIdentifier<T>, dependencyIndex?: number): T;
    private _sessionSessionInjectorMap;
    hasSessionInjector(session: Session): boolean;
    getSessionInjector(session: Session): Injector<Session>;
    destroySessionInjector(session: Session): boolean;
    call<Fn extends (this: ThisArg, ...args: any[]) => any, ThisArg>(fn: Fn, thisArg: ThisArg): ReturnType<Fn>;
    hasHook(hook: string): Promise<boolean>;
    callHookWithArgs<Args extends any[]>({ async, ...options }: {
        hook: string;
        args: Args;
        instantiate: boolean;
        async: boolean;
    }): {};
    callHookWithArgsSync<Args extends any[]>({ hook, args, instantiate }: {
        hook: string;
        args: Args;
        instantiate: boolean;
    }): {};
    callHookWithArgsAsync<Args extends any[]>({ hook, args, instantiate }: {
        hook: string;
        args: Args;
        instantiate: boolean;
    }): Promise<{}>;
}