type Ok<A> = {
    _tag: 'ok';
    value: A;
};
type Err<E> = {
    _tag: 'err';
    error: E;
};
type Die = {
    _tag: 'die';
    cause?: unknown;
};
export type Exit<A, E> = Ok<A> | Err<E> | Die;
export declare const Exit: {
    ok: <A>(value: A) => Exit<A, never>;
    err: <E>(error: E) => Exit<never, E>;
    die: (cause?: unknown) => Exit<never, never>;
    isOk: <A, E>(e: Exit<A, E>) => e is Ok<A>;
    isErr: <A, E>(e: Exit<A, E>) => e is Err<E>;
    isDie: <A, E>(e: Exit<A, E>) => e is Die;
};
export declare class Task<A, E> {
    private readonly effect;
    private constructor();
    run(signal: AbortSignal): Promise<Exit<A, E>>;
    fork(): {
        exit: Promise<Exit<A, E>>;
        abort: () => void;
    };
    unsafeRun(): Promise<Exit<A, E>>;
    map<B>(f: (a: A) => B): Task<B, E>;
    flatMap<B, E2>(f: (a: A) => Task<B, E2>): Task<B, E | E2>;
    tap(f: (a: A) => void | PromiseLike<void>): Task<A, E>;
    mapError<E2>(f: (e: E) => E2): Task<A, E2>;
    catchAll<B, E2>(f: (e: E) => Task<B, E2>): Task<A | B, E2>;
    catchWhen<K extends keyof E, V extends E[K], B, E2>(key: K, value: V, handler: (e: Extract<E, Record<K, V>>) => Task<B, E2>): Task<A | B, E2 | Exclude<E, Record<K, V>>>;
    filter<B extends A, E2>(predicate: (a: A) => a is B, onFalse: (a: A) => E2): Task<B, E | E2>;
    filter<E2>(predicate: (a: A) => boolean, onFalse: (a: A) => E2): Task<A, E | E2>;
    tapError(f: (e: E) => void | PromiseLike<void>): Task<A, E>;
    withTimeout(ms: number): Task<A, E | {
        _tag: 'TimeoutError';
        ms: number;
    }>;
    static succeed<A>(value: A): Task<A, never>;
    static fail<E>(error: E): Task<never, E>;
    static die(cause?: unknown): Task<never, never>;
    static never(): Task<never, never>;
    static sync<A>(thunk: () => A): Task<A, never>;
    static lazy<A, E>(thunk: () => Task<A, E>): Task<A, E>;
    static attempt<A, E>(options: {
        try: () => A | PromiseLike<A>;
        catch: (error: unknown) => E;
    }): Task<A, E>;
    static gen<Eff extends Task<any, any>, T>(f: () => Generator<Eff, T, any>): Task<T, Eff extends Task<any, infer E> ? E : never>;
    [Symbol.iterator](): Generator<Task<A, E>, A, any>;
}
export {};
//# sourceMappingURL=index.d.ts.map