import { Abortable } from '../abortable/abortable.class';
import { IAsyncTaskAllSettledValuesListReturn } from './async-task-all-settled-values-list-return.type';
import { IAsyncTaskConstraint } from './types/async-task-constraint.type';
import { IAsyncTaskInput } from './types/async-task-input.type';
import { IAsyncTaskFactory } from './types/factory/async-task-factory.type';
import { IGenericAsyncTaskFactoriesList } from './types/factory/generic-async-task-factories-list.type';
import { IAsyncTaskInitFunction } from './types/init/async-task-init-function.type';
import { IAsyncTaskOnAbortedFunction } from './types/methods/aborted/async-task-on-aborted-function.type';
import { IAsyncTaskOnErroredFunction } from './types/methods/errored/async-task-on-errored-function.type';
import { IAsyncTaskOnFinallyFunction } from './types/methods/finally/async-task-on-finally-function.type';
import { IAsyncTaskOnSuccessfulFunction } from './types/methods/successful/async-task-on-successful-function.type';
import { IAsyncTaskAllValuesListReturn } from './types/static-methods/all/async-task-all-values-list-return.type';
import { IAsyncTaskRaceValueReturn } from './types/static-methods/race/async-task-race-value-return.type';
export declare const ASYNC_TASK_SUCCESS: unique symbol;
export declare class AsyncTask<GValue extends IAsyncTaskConstraint<GValue>> {
    #private;
    /**
     * Creates an AsyncTask from an IAsyncTaskFactory.
     */
    static fromFactory<GValue extends IAsyncTaskConstraint<GValue>>(factory: IAsyncTaskFactory<GValue>, abortable: Abortable): AsyncTask<GValue>;
    /**
     * Creates a "successful" AsyncTask.
     * If "value" is an AsyncTask or Promise, then the returned AsyncTask will take the same state when resolved.
     */
    static success<GValue extends IAsyncTaskConstraint<GValue>>(value: IAsyncTaskInput<GValue>, abortable: Abortable): AsyncTask<GValue>;
    /**
     * Creates an "errored" AsyncTask.
     */
    static error<GValue extends IAsyncTaskConstraint<GValue> = any>(_error: any, abortable: Abortable): AsyncTask<GValue>;
    /**
     * Creates an AsyncTask that never complete (never enter in a "success" or "error" state).
     * However, it can still be aborted.
     */
    static never<GValue extends IAsyncTaskConstraint<GValue> = any>(abortable: Abortable): AsyncTask<GValue>;
    /**
     * Creates a "successful" AsyncTask, whose value is "undefined".
     */
    static void(abortable: Abortable): AsyncTask<void>;
    /**
     * Creates a AsyncTask, whose Abortable is aborted when "success" or "error" is called.
     * This is sometimes useful to clear some resources.
     */
    static abortOnFinished<GValue extends IAsyncTaskConstraint<GValue>>(init: IAsyncTaskInitFunction<GValue>, abortable: Abortable): AsyncTask<GValue>;
    /**
     * Returns an AsyncTask resolved with all the values returned by the factories (as an array).
     * If any of the AsyncTasks returned by the factories enters in an "error" state, the returned AsyncTask enters in an "error" state too,
     * add all other factories are aborted.
     */
    static all<GFactories extends IGenericAsyncTaskFactoriesList>(factories: GFactories, abortable: Abortable): AsyncTask<IAsyncTaskAllValuesListReturn<GFactories>>;
    /**
     * Returns an AsyncTask resolved with the first value or error returned by the factories.
     * When it appends, all the other factories are aborted.
     */
    static race<GFactories extends IGenericAsyncTaskFactoriesList>(factories: GFactories, abortable: Abortable): AsyncTask<IAsyncTaskRaceValueReturn<GFactories>>;
    /**
     * Returns a "successful" AsyncTask when all the factories are resolved.
     * The result is an array with the state of each of these factories.
     */
    static allSettled<GFactories extends IGenericAsyncTaskFactoriesList>(factories: GFactories, abortable: Abortable): AsyncTask<IAsyncTaskAllSettledValuesListReturn<GFactories>>;
    constructor(init: IAsyncTaskInitFunction<GValue>, abortable: Abortable);
    then<GNewValue extends IAsyncTaskConstraint<GNewValue>>(onSuccessful: IAsyncTaskOnSuccessfulFunction<GValue, GNewValue>, onErrored: IAsyncTaskOnErroredFunction<GNewValue>): AsyncTask<GNewValue>;
    successful<GNewValue extends IAsyncTaskConstraint<GNewValue>>(onSuccessful: IAsyncTaskOnSuccessfulFunction<GValue, GNewValue>): AsyncTask<GNewValue>;
    errored<GNewValue extends IAsyncTaskConstraint<GNewValue>>(onErrored: IAsyncTaskOnErroredFunction<GNewValue>): AsyncTask<GValue | GNewValue>;
    aborted<GNewValue extends IAsyncTaskConstraint<GNewValue>>(onAborted: IAsyncTaskOnAbortedFunction<GNewValue>, abortable?: Abortable): AsyncTask<GValue | GNewValue>;
    switchAbortable(abortable: Abortable): AsyncTask<GValue>;
    finally(onFinally: IAsyncTaskOnFinallyFunction<GValue>): AsyncTask<GValue>;
    toPromise(): Promise<GValue>;
}