/// <reference types="node" />
import { AsyncLocalStorage } from "async_hooks";
export declare enum ContainerScope {
    Value = "VALUE",
    Contextual = "CONTEXTUAL",
    Singleton = "SINGLETON",
    Transient = "TRANSIENT"
}
interface IClass<T = any> {
    new (...args: any): T;
}
export type ContainerIdentifer = string | symbol;
export type ContainerValueIdentifier<T = any> = string | symbol | CallableFunction | IClass<T>;
export type ContainerValue = IContainerValue | IContainerFactory;
export interface IContainerValue {
    id: ContainerValueIdentifier;
    scope: ContainerScope;
    value: any;
}
export interface IContainerFactory {
    id: ContainerValueIdentifier;
    scope: ContainerScope;
    factory: CallableFunction;
    deps: Array<ContainerValueIdentifier>;
}
export declare class Container {
    protected asyncLocalStorage?: AsyncLocalStorage<any> | undefined;
    readonly id: ContainerIdentifer;
    static contextRegistryKey: string;
    protected registry: Map<ContainerValueIdentifier<any>, ContainerValue>;
    protected resolvedRegistry: Map<ContainerValueIdentifier<any>, any>;
    constructor(id: ContainerIdentifer, asyncLocalStorage?: AsyncLocalStorage<any> | undefined);
    findRegistryValue(id: ContainerValueIdentifier): ContainerValue | undefined;
    putRegistryValue(value: ContainerValue): void;
    cloneWith(id: ContainerIdentifer, ...args: ContainerValueIdentifier[]): Container;
    /**
     * create error with identifier
     * @param id container id
     * @param message error message
     * @returns
     */
    createErrorWithIdentifier(id: ContainerValueIdentifier, message: string): Error;
    /**
     * add or replace
     * @param {ContainerValue} data
     * @param {boolean} replace
     */
    register(data: ContainerValue, replace?: boolean): void;
    delete(id: ContainerValueIdentifier): void;
    has(id: ContainerValueIdentifier): boolean;
    /**
     * only set if not exists
     * @param data
     * @returns
     */
    set(data: ContainerValue): void;
    /**
     * set or replace
     * @param data
     * @returns
     */
    put(data: ContainerValue): void;
    /**
     * value scope, for static values
     * @param id
     * @returns
     */
    value<T>(id: ContainerValueIdentifier): T;
    /**
     * check if container already have resolved value
     * @param id
     * @returns
     */
    hasResolved(id: ContainerValueIdentifier): boolean;
    protected valueResolver(data: ContainerValue): any;
    /**
     * unused
     * @param data
     * @returns
     */
    protected factoryResolver(data: ContainerValue): any;
    /**
     * use to resolve async deps
     * @param id
     * @returns
     */
    resolveAsync<T>(id: ContainerIdentifer): Promise<T>;
    /**
     * resolve service with given identifier
     * @param id
     * @returns
     */
    resolve<T>(id: ContainerValueIdentifier): T;
    /**
     * does not consider/respect scope, always return fresh value if possible,
     * as static value will be always be stale
     * @param id
     * @returns
     */
    fresh<T>(id: ContainerValueIdentifier): T;
    /**
     * call a function with given deps
     * @param cb
     * @param deps
     * @returns
     */
    call(cb: Function, deps?: Array<ContainerIdentifer>): any;
    /**
     * call a async function or when you have async deps
     * @param cb
     * @param deps
     * @returns
     */
    callAsync(cb: Function, deps?: Array<ContainerIdentifer>): Promise<any>;
    /**
     * pre-resolve all Singleton deps
     */
    preresolve(): void;
    /**
     * each context will have different registry
     * @returns
     */
    protected ctxRegistry(): Map<ContainerValueIdentifier, any>;
    setAsyncLocalStorage(asyncLocalStorage: AsyncLocalStorage<any>): void;
    contextStore<T = any>(): T;
    contextStoreSet(k: string, v: any): void;
    contextStoreGet<T = any>(k: string): T | undefined;
    asyncLocalRun(store: any, cb: CallableFunction): unknown;
}
export {};