import 'reflect-metadata';
export declare enum SupportedInjectableService {
    function = "function",
    class = "class",
    object = "object",
    other = "other"
}
declare enum Scope {
    singleton = "singleton",
    scoped = "scoped"
}
type Constructable<T = any> = new (...args: any[]) => T;
interface IDependency<T> {
    name: string | symbol;
    service: Constructable<T> | T;
    instance?: T;
    scope: Scope;
    type: SupportedInjectableService;
}
interface IDIServiceOptions {
    name?: string | symbol;
    scope?: Scope;
}
export declare class Container {
    dependencies: Map<string | symbol, IDependency<any>>;
    name: string;
    constructor(name: string | symbol);
    Bind<T>(service: Constructable<T> | T, options?: IDIServiceOptions): this;
    resolve<T>(name: string | symbol): T;
    resolveAll(): Record<string, any>;
}
type Callback<T> = (...args: any[]) => T;
type InferParameters<T> = T extends (...args: infer P) => any ? P : never;
type InferParametersXFirstArg<T> = T extends (...args: [infer A, ...infer P]) => any ? [...P] : never;
type IsFunction<T> = T extends (...args: any[]) => infer R ? R extends (...args: any[]) => any ? InferParameters<R> : InferParametersXFirstArg<T> : never;
type IsFunctionForReturnType<T> = T extends (...args: any[]) => infer R ? R extends (...args: any[]) => any ? ReturnType<R> : ReturnType<T> : never;
export declare function GetContainer(container?: string | symbol): Container;
export declare function InjectIn<T extends Callback<any>>(callback: T, options?: {
    containers?: string[];
    callbackName?: string;
    resolveType?: 'eager' | 'lazy';
}): (...args: IsFunction<T>) => IsFunctionForReturnType<T>;
export declare function SetDefaultContainer(name: string | symbol): void;
export {};