import { Maybe } from "../Maybe";
import { Result } from "../Result";
export declare type IO<E, A> = Succeed<A> | Die | Fail<E> | Suspend<E, A> | Async<E, A> | FlatMap<E, any, A>;
/**
  UIO is a type alias for IO<never, A>, which represents an effect
  that cannot fail, but can succeed with an A.
*/
export declare type UIO<A> = IO<never, A>;
declare type Succeed<A> = {
    tag: "Succeed";
    a: A;
};
declare type Fail<E> = {
    tag: "Fail";
    e: E;
};
declare type Die = {
    tag: "Die";
    e: unknown;
};
declare type Async<E, A> = {
    tag: "Async";
    onDone: (onError: (e: E) => unit, onSuccess: (a: A) => unit, onDie: (e: unknown) => unit) => unit;
};
declare class Suspend<E, A> {
    readonly lazy: () => IO<E, A>;
    tag: "Suspend";
    _E: E;
    _A: A;
    constructor(lazy: () => IO<E, A>);
}
declare class FlatMap<E, A0, A> {
    readonly aToIOB: (a: A0) => IO<E, A>;
    readonly ioA: IO<E, A0>;
    tag: "FlatMap";
    _E: E;
    _A0: A0;
    _A: A;
    constructor(aToIOB: (a: A0) => IO<E, A>, ioA: IO<E, A0>);
}
declare type unit = void;
/**
 **succeed** constructs a success IO from the provided value.
 */
export declare const succeed: <E, A>(a: A) => IO<E, A>;
/**
 **unit** represents an IO that successfully resolves to void.
 */
export declare const unit: IO<never, void>;
/**
 **fail** wraps a strictly-evaluated error value in an error IO.
 */
export declare const fail: <E, A>(e: E) => IO<E, A>;
/**
 **die** constructs an IO that will die by throwing the given `e`.
 */
export declare const die: <E, A>(e: E) => IO<never, A>;
/**
 **sync** wraps a lazily-evaluated value of type A in a success IO.
 */
export declare const sync: <E, A>(lazy: () => A) => IO<E, A>;
/**
 **syncFail** wraps a lazily-evaluated value of type E in an error IO.
 */
export declare const syncFail: <E, A>(lazy: () => E) => IO<E, A>;
/**
 **suspend** wraps a lazily-evaluated IO value in an IO.
 */
export declare const suspend: <E, A>(lazy: () => IO<E, A>) => IO<E, A>;
/**
   **async** creates an async IO value that is run by invoking a callback.
 
   Example:
 
   ```ts
   async((onF, onS) => onS(1));
   async((onF, onS) => onF(new Error('Failed')));
   async((onF, onS, onE) => onE(new Error('Failed')));
   ```
 */
export declare const async: <E, A>(onDone: (onError: (e: E) => unit, onSuccess: (a: A) => unit, onDie: (e: unknown) => unit) => unit) => IO<E, A>;
/**
  IO.**fromMaybe** lifts an evaluated Maybe<A> to an IO<E, A> by providing a
  fallback E value to use when the Maybe is `Nothing`.
*/
export declare const fromMaybe: <E, A>(fallback: E) => (ma: Maybe<A>) => IO<E, A>;
/**
  IO.**fromNullable** lifts a nullable value to an IO<E, A> by providing a
  fallback E value to use when the value is `null` or `undefined`.
*/
export declare const fromNullable: <E, A>(fallback: E) => (a: A | null | undefined) => IO<E, A>;
/**
  IO.**fromResult** lifts an evaluated result value of type Result<E, A> to an IO<E, A>.
*/
export declare const fromResult: <E, A>(result: Result<E, A>) => IO<E, A>;
/**
  IO.**tryCatch** lifts a lazy function (() => A) that can throw an unknown exception to an IO<unknown, A>.
*/
export declare const tryCatch: <A>(f: () => A) => IO<unknown, A>;
/**
  IO.**fromPromise** lifts a lazyily-evaluated promise into an async IO value.
*/
export declare const fromPromise: <A>(lazy: () => Promise<A>) => IO<unknown, A>;
/**
  IO.**fromPromiseOrDie** lifts a lazyily-evaluated promise into an async IO value and eliminates the error channel
*/
export declare const fromPromiseOrDie: <A>(lazy: () => Promise<A>) => UIO<A>;
/**
 **sleep** creates an async IO that will sleep for the given millisecond duration.
 */
export declare const sleep: (duration: number) => IO<never, void>;
/**
 **ioify** lifts a node style callback function to one returning an `IO`
 */
export declare function ioify<L, R>(f: (cb: (e: L | null | undefined, r?: R) => void) => void): () => IO<L, R>;
export declare function ioify<A, L, R>(f: (a: A, cb: (e: L | null | undefined, r?: R) => void) => void): (a: A) => IO<L, R>;
export declare function 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>;
export declare function 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>;
export declare function 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>;
export declare function 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>;
/**
 **traverse** converts an Array<A> to an IO<E, Array<B>> where each element of the array is ran through the given `f`.

 It is useful when you have an array of items you want to run an effect on each item without ending up with an Array<IO<E, B>>,
 instead having just one IO.
 */
export declare const traverse: <E, A, B>(f: (a: A) => IO<E, B>) => (args: A[]) => IO<E, B[]>;
/**
 **forEach** converts an Array<A> to an IO<E, Array<B>> where each element of the array is ran through the given `f`.

 It is useful when you have an array of items you want to run an effect on each item without ending up with an Array<IO<E, B>>,
 instead having just one IO.
 */
export declare const forEach: <A>(args: A[]) => <E, B>(f: (a: A) => IO<E, B>) => IO<E, B[]>;
/**
  IO.**lift** lifts a function of (A => B) into a function of (A => IO<E, A>).
*/
export declare const lift: <E, A, B>(f: (a: A) => B) => (a: A) => IO<E, B>;
/**
  **flatMap** applies an effectful function (A => IO<E, B>) on the success channel
  to produce an IO<E, B>.
*/
export declare const flatMap: <E, A, B>(f: (a: A) => IO<E, B>) => (io: IO<E, A>) => IO<E, B>;
/**
  **flatMapW** applies an effectful function (A => IO<E1, B>) on the success channel
  to produce an IO<E | E1, B> growing the error channel with E1.
*/
export declare const flatMapW: <E, E1, A, B>(f: (a: A) => IO<E1, B>) => (io: IO<E, A>) => IO<E | E1, B>;
/**
 **map** applies a function (**A** => **B**) on an IO<E, **A**> success channel to produce an IO<E, **B**>.
 */
export declare const map: <E, A, B>(f: (a: A) => B) => (io: IO<E, A>) => IO<E, B>;
/**
  **handleError** applies a function (E => A) on the error channel
  to convert an error value to a success value, which serves to "clear" the error in the IO,
  making the error type `never`.
*/
export declare const handleError: <E, A>(f: (e: E) => A) => (io: IO<E, A>) => IO<never, A>;
/**
  **flatHandleError** applies an effectful function (E => IO<never, A>) on the error channel
  to convert an error value to a success value, which serves to "clear" the error in the IO,
  making the error type `never`.
*/
export declare const flatHandleError: <E, A>(f: (e: E) => IO<never, A>) => (io: IO<E, A>) => IO<never, A>;
/**
  **catchError** applies an effectful function (E => IO<E1, A>) on the error channel
  to produce an IO<E1, A>.
*/
export declare const catchError: <E, E1, A>(f: (e: E) => IO<E1, A>) => (io: IO<E, A>) => IO<E1, A>;
/**
  **mapError** applies a function (**E** => **E1**) on an IO<**E**, A> error channel to produce an
  IO<**E1**, A>.
*/
export declare const mapError: <E, E1, A>(f: (e: E) => E1) => (io: IO<E, A>) => IO<E1, A>;
/**
  IO.**biFlatMap** applies flatMap functions on both the success and failure channels of the IO. Equivalent to:
  ```ts
  io.flatMap(f).flatMapFailure(g);
  ```
*/
export declare const biFlatMap: <E, E1, A, B>(g: (e: E) => IO<E1, B>, f: (a: A) => IO<E, B>) => (io: IO<E, A>) => IO<E1, B>;
/**
 **bimap** applies map functions on both the success and error channels of the IO.
 */
export declare const bimap: <E, E1, A, B>(f: (e: E) => E1, g: (a: A) => B) => (io: IO<E, A>) => IO<E1, B>;
/**
  IO.**flatTap** applies a side-effect function (A => UIO<unit>) on an IO<E, A> success channel,
  and propagates the A value unchanged.
  This is useful for doing things like logging the value inside the IO.
*/
export declare const flatTap: <E, A>(f: (a: A) => UIO<unit>) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**tap** applies a side-effect function (A => unit) on an IO<E, A> success channel,
  and propagates the A value unchanged.
  This is useful for doing things like logging the value inside the IO.
*/
export declare const tap: <E, A>(f: (a: A) => unit) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**tapError** applies a side-effect function (E => unit) on an IO<E, A> error channel,
  and propagates the E value unchanged.
  This is useful for doing things like logging the value inside the IO.
*/
export declare const tapError: <E, A>(f: (e: E) => unit) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**biFlatTap** applies a side-effect function to an IO to both channels,
  and propagates the values unchanged.
  This is useful for doing things like logging the value inside the IO..
 */
export declare const biFlatTap: <E, A>(f: (e: E) => UIO<unit>, g: (a: A) => UIO<unit>) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**flatTapError** applies a side-effect function (E => UIO<unit>) on an IO<E, A> error channel,
  and propagates the E value unchanged.
  This is useful for doing things like logging the error inside the IO.
*/
export declare const flatTapError: <E, A>(f: (e: E) => UIO<unit>) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**biTap** applies a side-effect function to both channels,
  and propagates the values unchanged.
  This is useful for doing things like logging the value inside the IO.
*/
export declare const biTap: <E, A>(f: (e: E) => unit, g: (a: A) => unit) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**orDie** will throw the E value if ran on a failed IO and will eliminate the E type
  completely resulting in an IO<never, A>.

  This is useful for dealing with exceptions that cannot be recovered in the IO context.
*/
export declare const orDie: <E, A>(io: IO<E, A>) => UIO<A>;
/**
  IO.**toUnit** converts a successful IO to void
*/
export declare const toUnit: <E, A>(io: IO<E, A>) => IO<E, void>;
/**
  IO.**nothing** converts a successful IO to void and kills a failed IO

  Syntaxical sugar for: `IO.toUnit.orDie`
*/
export declare const nothing: <E, A>(io: IO<E, A>) => UIO<void>;
/**
  IO.**filter** interrogates the success channel with a given predicate which when fails converts the IO
  to an error with the given fallback
*/
export declare const filter: <E, A>(p: (a: A) => boolean, e: E) => (io: IO<E, A>) => IO<E, A>;
/**
  IO.**filterWith** interrogates the success channel with a given predicate which when fails converts the IO
  to an error using the given `f` to produce a newly typed error E1
*/
export declare const filterWith: <E, E1, A>(p: (a: A) => boolean, f: (a: A) => E1) => (io: IO<E, A>) => IO<E | E1, A>;
/**
  IO.**refine** runs the given refinement function on the success channel to allow the `A` to be changed to `B`.
  If refinement fails the IO is converted to an error with the given fallback
*/
export declare const refine: <E, E1, A, B extends A>(p: (a: A) => a is B, e: E | E1) => (io: IO<E, A>) => IO<E | E1, B>;
/**
  IO.**refineErrorOrDie** runs the given refinement function on the error channel to allow the `E` to be changed to `E1`.
  IO dies if the result of the given refinement function is `Maybe.nothing`.
*/
export declare const refineErrorOrDie: <E, E1, A>(f: (e: E) => Maybe<E1>) => (io: IO<E, A>) => IO<E1, A>;
/**
  IO.**merge** joins the error and success channel into a success UIO<A | E>.

  This is useful when you need to work over a success value and both A and E have a shared super type.
*/
export declare const merge: <E, A>(io: IO<E, A>) => UIO<E | A>;
/**
  IO.**fold** converts the IO to a UIO<B> that cannot fail by running the success and error channels over
  the given functions and merges the results
*/
export declare const fold: <E, A, B>(f: (e: E) => B, g: (a: A) => B) => (io: IO<E, A>) => UIO<B>;
/**
 **flip** Flips the values between the success and error channels.
 */
export declare const flip: <E, A>(io: IO<E, A>) => IO<A, E>;
/**
 **delay** delays the exectuion of a successful IO by the giving time in milliseconds
 */
export declare const delay: <E, A>(duration: number) => (io: IO<E, A>) => IO<E, A>;
/**
  **unsafeRunAsync** runs the effectual IO<E, A> and applies the given onFailure and
  onSuccess callbacks to the outcome of the IO depending on the channel the IO ends in
  and if the effect dies the onDie callback is invoked.

  This function should be run "at the edge of the world" to evaluate the
  suspended side-effects in the IO.
*/
export declare const unsafeRunAsync: <E, A>(onFailure: (e: E) => unit, onSuccess: (a: A) => unit, onDie: (e: unknown) => unit) => (io: IO<E, A>) => unit;
/**
  **unsafeRunAsyncOrDie** runs the effectual IO<E, A> and applies the given onFailure and
  onSuccess callbacks to the outcome of the IO depending on the channel the IO ends in.

  _Note:_ Should the effect die then this error will be thrown.

  This function should be run "at the edge of the world" to evaluate the
  suspended side-effects in the IO.
*/
export declare const unsafeRunAsyncOrDie: <E, A>(onFailure: (e: E) => unit, onSuccess: (a: A) => unit) => (io: IO<E, A>) => unit;
/**
  IO.**toPromise** runs the effectual IO<A, E> and lifts the outcome into a `Promise`.
  In doing so it throws away the failure channel (E) type information.

  This function should be run "at the edge of the world" to evaluate the
  suspended side-effects in the IO.
*/
export declare const toPromise: <E, A>(io: IO<E, A>) => Promise<A>;
export declare class GenIO<E, A> {
    readonly op: IO<E, A>;
    constructor(op: IO<E, A>);
    [Symbol.iterator](): Generator<GenIO<E, A>, A, any>;
}
export declare const gen: <Eff extends GenIO<any, any>, AEff>(f: (i: <E, A>(_: IO<E, A>) => GenIO<E, A>) => Generator<Eff, AEff, any>) => IO<_E<Eff["op"]>, AEff>;
export declare type _E<T> = T extends Fail<infer E> | Suspend<infer E, any> | Async<infer E, any> | FlatMap<infer E, any, any> ? E : never;
export {};