export type Status = "idle" | "processing" | "success" | "failed";
export interface AbstractTaskState<S extends Status> {
    status: S;
}
export type TaskFailureReason = "timeout" | "aborted" | "error";
export interface AbstractFailedTask<R extends TaskFailureReason> extends AbstractTaskState<"failed"> {
    reason: R;
}
export interface TaskFailedByError<E> extends AbstractFailedTask<"error"> {
    error: E;
}
export type FailedTask<E> = TaskFailedByError<E> | AbstractFailedTask<"timeout"> | AbstractFailedTask<"aborted">;
export interface ProcessingTask<T, R> extends AbstractTaskState<"processing"> {
    delayed: boolean;
    args: T;
    promise: Promise<R>;
    abortController: AbortController;
}
export type TaskState<T, R, E> = AbstractTaskState<"idle"> | ProcessingTask<T, R> | AbstractTaskState<"success"> | FailedTask<E>;
export type TasksCombinatorDecision = boolean | "abort" | "untrack";
export type TasksCombinator<T, R, E> = (state: TaskState<T, R, E>) => TasksCombinatorDecision;
export interface TaskOptions<T extends ReadonlyArray<any>, R, E> {
    execute: (signal: AbortSignal, ...args: T) => Promise<R>;
    onSuccess?: (result: R, ...args: T) => void;
    onFailure?: (failure: FailedTask<E>, ...args: T) => void;
    /**
     * The `combinator` runtime error is interpreted as `false`.
     * @default waitPrevious
     */
    combinator?: TasksCombinator<T, R, E>;
    /**
     * @default 500
     */
    delayedMs?: number;
    /**
     * @default 8000
     */
    timeoutMs?: number;
}
/**
 * Forget previous task
 */
export declare const forgetPrevious: TasksCombinator<any, any, any>;
/**
 * Abort previous task
 */
export declare const abortPrevious: TasksCombinator<any, any, any>;
/**
 * Ignore new tasks until the previous task is completed
 */
export declare const waitPrevious: TasksCombinator<any, any, any>;
export declare function throttle<T, R, E>(combinator: TasksCombinator<T, R, E>, delayedMs: number): TasksCombinator<T, R, E>;
export declare class InitializationError<T, R, E> {
    readonly state: TaskState<T, R, E>;
    constructor(state: TaskState<T, R, E>);
}
export declare class CompletionError<E> {
    readonly state: FailedTask<E>;
    constructor(state: FailedTask<E>);
}
export interface Task<T extends ReadonlyArray<any>, R, E> {
    readonly state: Readonly<TaskState<T, R, E>>;
    readonly status: Status;
    readonly isSuccess: boolean;
    readonly isFailed: boolean;
    readonly isProcessed: boolean;
    readonly isDelayed: boolean;
    matches<S extends Status>(status: S): this is Task<T, R, E> & {
        status: S;
        state: Readonly<Extract<TaskState<T, R, E>, AbstractTaskState<S>>>;
    };
    /**
     * Initiates the task without waiting for its result.
     * Any side effects or failures are handled internally.
     */
    run(...args: T): void;
    /**
     * Initiates the task and returns a promise that resolves when the task completes.
     * Use this method when you need to handle the result or catch errors.
     * @throws {InitializationError} if combinator returns `false`.
     * @throws {CompletionError} if task were aborted or timeouted.
     */
    runAsync(...args: T): Promise<R>;
    /**
     * Aborts the ongoing task if it is currently processing.
     * The task will fail with an "aborted" reason and trigger any associated failure callbacks.
     */
    abort(): void;
}
export declare function createTask<T extends ReadonlyArray<any>, R = unknown, E = unknown>(options: TaskOptions<T, R, E>): Task<T, R, E>;