/**
 * Copyright 2023 Kapeta Inc.
 * SPDX-License-Identifier: BUSL-1.1
 */
import { LogLevel } from './types';
export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
export declare enum TaskStatus {
    PENDING = "PENDING",
    RUNNING = "RUNNING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED"
}
interface Future<T = void> {
    promise: Promise<T>;
    resolve: (result: T) => void;
    reject: (e: any) => void;
}
interface TaskMetadata {
    name: string;
    /**
     * A unique prefix for the task. If defined only 1 task with this ID prefix will be executed at a time
     */
    group?: string;
    progress?: number;
    [key: string]: any;
}
interface TaskData<T = void> {
    id: string;
    status: TaskStatus;
    errorMessage?: string;
    metadata: TaskMetadata;
    future: Future<T>;
    run: TaskRunner<T>;
}
export declare class Task<T = void> implements TaskData<T> {
    private data;
    constructor(task: TaskData<T>);
    get id(): string;
    get status(): TaskStatus;
    get errorMessage(): string | undefined;
    get metadata(): TaskMetadata;
    get future(): Future<T>;
    get run(): TaskRunner<T>;
    set status(status: TaskStatus);
    set errorMessage(errorMessage: string | undefined);
    set metadata(metadata: TaskMetadata);
    emitUpdate(): void;
    addLog(log: string, level?: LogLevel): void;
    wait(): Promise<T>;
    toData(): {
        id: string;
        status: TaskStatus;
        errorMessage?: string | undefined;
        metadata: TaskMetadata;
        future: Future<T>;
        run: TaskRunner<T>;
    };
}
declare class TaskManager {
    private _tasks;
    add<T>(id: string, runner: TaskRunner<T>, metadata: TaskMetadata): Task<T>;
    waitFor(filter: (task: Task<any>) => boolean): Promise<void>;
    get(taskId: string): Task<any> | undefined;
    exists(taskId: string): boolean;
    remove(taskId: string): void;
    list(): TaskData[];
    private invokeTask;
}
export declare const taskManager: TaskManager;
export {};