import { Logger } from "winston";
import { U } from "ts-toolbelt";
declare class Confidant_<C extends Record<string, any>, Ms extends Record<string, TaskMaker<C, any>>> {
    context: C;
    tasks: {
        [K in keyof Ms]: Task<C, TaskMakerResult<Ms[K]>>;
    };
    globalTimeout: number;
    timeout: string;
    logger: Logger;
    constructor(context: C, taskMakers: Ms, options: {
        logger: Logger;
        timeout: string;
    });
    onInitialize<K extends keyof Ms>(key: K, fn: (value: TaskMakerResult<Ms[K]>) => void): () => void;
    onUpdate<K extends keyof Ms>(key: K, fn: (value: TaskMakerResult<Ms[K]>) => void): () => void;
    replaceKey<K extends keyof Ms>(key: K, taskMaker: Ms[K]): Promise<void>;
    keyForTask(task: Task<any, any>): string | undefined;
    get<K extends keyof Ms>(key: K): Promise<TaskMakerResult<Ms[K]>>;
    initialize<R extends {
        [K in keyof Ms]: TaskMakerResult<Ms[K]>;
    }>(): Promise<R>;
    runInitialize<K extends keyof Ms>(key: K): Promise<TaskMakerResult<Ms[K]>>;
    invalidate(path: string): Promise<void>;
}
declare type ValueOf<T> = T[keyof T];
declare type KeyToContext<O extends {
    [key: string]: TaskMaker<any, any>;
}> = {
    [K in keyof O]: TaskMakerContext<O[K]>;
};
export declare type GetContext<O extends {
    [key: string]: TaskMaker<any, any>;
}> = Omit<U.Merge<ValueOf<KeyToContext<O>>>, "__empty">;
export declare const Confidant: <Ms extends {
    [key: string]: TaskMaker<any, any>;
}, Cs extends GetContext<Ms>>(context: Cs, taskMakers: Ms, options?: {
    logger?: Logger | undefined;
    timeout?: string | undefined;
} | undefined) => Confidant_<Cs, Ms>;
export declare type Confidant<C extends Record<string, any>, Ms extends Record<string, TaskMaker<C, any>>> = Confidant_<C, Ms>;
export declare enum TaskState {
    PENDING = "PENDING",
    INITIALIZED = "INITIALIZED",
    UPDATING = "UPDATING",
    DESTROYED = "DESTROYED"
}
export declare class Task<C, V> {
    confidant_: Confidant<C, Record<string, any>>;
    state: TaskState;
    currentValue_: V | undefined;
    timeout_: number;
    initListeners: Set<(value: V) => void>;
    updateListeners: Set<(value: V) => void>;
    constructor(confidant_: Confidant<C, Record<string, any>>, timeout?: string);
    validateContext_(): boolean;
    get logger(): Logger;
    initialize(): Promise<V>;
    get(): Promise<V>;
    onInitialize(fn: (value: V) => void): () => void;
    onUpdate(fn: (value: V) => void): () => void;
    set(value: V): void;
    update(fn: (currentValue: V) => V): void;
    runInitialize(): Promise<V>;
    destroy(): void;
    onDestroy_(): void;
    invalidate(path?: string): Promise<void>;
}
export declare type TaskMaker<C extends Record<string, any>, V> = (confidant: Confidant<C, Record<string, any>>) => Task<C, V>;
export declare type TaskMakerResult<T extends TaskMaker<any, any>> = T extends TaskMaker<any, infer V> ? V : never;
export declare type TaskMakerContext<T extends TaskMaker<Record<string, any>, any>> = T extends TaskMaker<infer C, any> ? C : never;
export declare type TaskResult<T extends Task<any, any>> = T extends Task<any, infer V> ? V : never;
export {};
//# sourceMappingURL=task.d.ts.map