import { Maybe } from '../Maybe';
import { Result } from '../Result';
import * as _IO from './';
export declare type UIO<A> = IO<never, A>;
export declare class IO<E, A> {
    private readonly value;
    static succeed: <E_1, A_1>(a: A_1) => IO<E_1, A_1>;
    static unit: IO<never, void>;
    static fail: <E_1, A_1>(e: E_1) => IO<E_1, A_1>;
    static die: <E_1, A_1>(e: E_1) => IO<never, A_1>;
    static sync: <E_1, A_1>(lazy: () => A_1) => IO<E_1, A_1>;
    static syncFail: <E_1, A_1>(lazy: () => E_1) => IO<E_1, A_1>;
    static suspend: <E_1, A_1>(lazy: () => IO<E_1, A_1>) => IO<E_1, A_1>;
    static async: <E_1, A_1>(onDone: (onError: (e: E_1) => unit, onSuccess: (a: A_1) => unit, onDie: (e: unknown) => unit) => unit) => IO<E_1, A_1>;
    static fromResult: <E_1, A_1>(result: Result<E_1, A_1>) => IO<E_1, A_1>;
    static fromMaybe: <E_1, A_1>(fallback: E_1) => (ma: Maybe<A_1>) => IO<E_1, A_1>;
    static fromNullable: <E_1, A_1>(fallback: E_1) => (a: A_1 | null | undefined) => IO<E_1, A_1>;
    static tryCatch: <A_1>(f: () => A_1) => IO<unknown, A_1>;
    static fromPromise: <A_1>(lazy: () => Promise<A_1>) => IO<unknown, A_1>;
    static fromPromiseOrDie: <A_1>(lazy: () => Promise<A_1>) => UIO<A_1>;
    static sleep: (duration: number) => IO<never, void>;
    static lift: <E_1, A_1, B>(f: (a: A_1) => B) => (a: A_1) => IO<E_1, B>;
    static traverse: <E_1, A_1, B>(f: (a: A_1) => IO<E_1, B>) => (args: A_1[]) => IO<E_1, B[]>;
    static forEach: <A_1>(args: A_1[]) => <E_1, B>(f: (a: A_1) => IO<E_1, B>) => IO<E_1, B[]>;
    static ioify<L, R>(f: (cb: (e: L | null | undefined, r?: R) => void) => void): () => IO<L, R>;
    static ioify<A, L, R>(f: (a: A, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A) => IO<L, R>;
    static ioify<A, B, L, R>(f: (a: A, b: B, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A, b: B) => IO<L, R>;
    static ioify<A, B, C, L, R>(f: (a: A, b: B, c: C, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A, b: B, c: C) => IO<L, R>;
    static ioify<A, B, C, D, L, R>(f: (a: A, b: B, c: C, d: D, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A, b: B, c: C, d: D) => IO<L, R>;
    static ioify<A, B, C, D, E, L, R>(f: (a: A, b: B, c: C, d: D, e: E, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A, b: B, c: C, d: D, e: E) => IO<L, R>;
    private constructor();
    private to_IO;
    map: <B>(f: (a: A) => B) => IO<E, B>;
    flatMap: <B>(f: (a: A) => IO<E, B>) => IO<E, B>;
    flatMapW: <E1, B>(f: (a: A) => IO<E1, B>) => IO<E | E1, B>;
    mapError: <E1>(f: (e: E) => E1) => IO<E1, A>;
    catchError: <E1>(f: (e: E) => IO<E1, A>) => IO<E1, A>;
    handleError: (f: (e: E) => A) => IO<never, A>;
    flatHandleError: (f: (e: E) => IO<never, A>) => IO<never, A>;
    bimap: <E1, B>(f: (e: E) => E1, g: (a: A) => B) => IO<E1, B>;
    tap: (f: (a: A) => unit) => IO<E, A>;
    tapError: (f: (e: E) => unit) => IO<E, A>;
    biTap: (f: (e: E) => unit, g: (a: A) => unit) => IO<E, A>;
    flatTap: (f: (a: A) => UIO<void>) => IO<E, A>;
    flatTapError: (f: (e: E) => UIO<void>) => IO<E, A>;
    refineErrorOrDie: <E1>(f: (e: E) => Maybe<E1>) => IO<E1, A>;
    biFlatTap: (f: (e: E) => UIO<void>, g: (a: A) => UIO<void>) => IO<E, A>;
    flip: () => IO<A, E>;
    delay: (duration: number) => IO<E, A>;
    filter: (p: (a: A) => boolean, e: E) => IO<E, A>;
    refine: <B extends A, E1>(p: (a: A) => a is B, e: E | E1) => IO<E | E1, B>;
    filterWith: <E1>(p: (a: A) => boolean, f: (a: A) => E1) => IO<E | E1, A>;
    unsafeRunAsync: (onFailure: (e: E) => unit, onSuccess: (a: A) => unit, onDie: (e: unknown) => unit) => unit;
    unsafeRunAsyncOrDie: (onFailure: (e: E) => unit, onSuccess: (a: A) => unit) => unit;
    toPromise: () => Promise<A>;
    orDie: () => UIO<A>;
    toUnit: () => IO<E, void>;
    nothing: () => IO<never, void>;
    merge: () => UIO<E | A>;
    fold: <B>(f: (e: E) => B, g: (a: A) => B) => UIO<B>;
    static do: <Eff extends _IO.GenIO<any, any>, AEff>(f: (i: <E_1, A_1>(_: IO<E_1, A_1>) => _IO.GenIO<E_1, A_1>) => Generator<Eff, AEff, any>) => IO<_IO._E<Eff["op"]>, AEff>;
}
declare type unit = void;
export {};