import { Provider } from './Providers/Provider';
import { Class } from './Providers/ClassProvider';
import { Scope } from './Scope';
interface Cached<T> {
    value: T;
    owner: BaseInjector;
    injector: BaseInjector;
}
export declare enum InjectFlags {
    Default = 0,
    Optional = 1,
    SkipSelf = 2,
    Self = 4,
    SkipCache = 8,
    DontCache = 16,
    Scoped = 32,
    Unscoped = 64
}
export declare class TokenNotFoundError extends Error {
    constructor(token: any);
}
export declare class InvalidTagProviderError extends Error {
    constructor(token: any);
}
export declare class BaseInjector {
    parent: BaseInjector;
    scope: Scope;
    /**
     * In order to avoid going up the injectors' tree, cache
     */
    protected providersCache?: Map<any, Cached<Provider<any>>>;
    /**
     * Some dependencies can be cached and don't need to be resolved all the time
     */
    protected cache?: Map<any, Cached<any>>;
    /**
     * Associates an identifying token with each provider
     */
    protected providers: Map<any, Provider<any>>;
    readonly mutable: boolean;
    constructor(providers?: (Class<any> | Provider<any>)[], parent?: BaseInjector, scope?: boolean | number | Scope);
    protected add(provider: Class<any> | Provider<any>): void;
    /**
     * Traverses up the injector chain looking for a matching token provider. It then analyzes the token and identifies it's scope.
     */
    protected locateInternal<T>(token: any, flags?: InjectFlags, forceProviders?: boolean): [BaseInjector, BaseInjector, Provider<T>, T, boolean];
    locate<T>(token: any, flags?: InjectFlags): [Injector, Injector, Provider<T>];
    get<T>(token: Class<T>, flags?: InjectFlags): T;
    get<T>(token: any, flags?: InjectFlags): T;
    create<T>(constructor: Class<T>, args?: any[], flags?: InjectFlags): T;
    createChild(providers?: (Class<any> | Provider<any>)[], scope?: boolean | number | Scope): BaseInjector;
    tag(tag: any, tokens: any[]): void;
    call<T, M extends keyof T>(objectClass: T, method: M, ...manualArgs: any[]): T[M] extends ((...args: any[]) => (infer R)) ? R : string;
    call<T, M extends keyof T>(objectClass: Class<T>, method: null | undefined, ...manualArgs: any[]): T;
}
export declare class MutableInjector extends BaseInjector {
    readonly mutable: boolean;
    add(provider: Class<any> | Provider<any>): void;
    set(token: any, provider: Class<any>, scope?: number): void;
}
export declare class Injector extends BaseInjector {
    static readonly main: MutableInjector;
    static get<T>(token: Class<T>, flags?: InjectFlags): T;
    static get<T>(token: any, flags?: InjectFlags): T;
    static create<T>(constructor: Class<T>, args?: any[], flags?: InjectFlags): T;
    static createChild(providers: (Class<any> | Provider<any>)[]): BaseInjector;
    static createRoot(providers?: (Class<any> | Provider<any>)[], scope?: number): BaseInjector;
    static add(provider: Class<any> | Provider<any>): void;
    static set(token: any, provider: Class<any>): void;
}
export {};