/**
 * The AsyncEither datastructure represents an asynchronous operation that can
 * fail. At its heart it is implemented as `() => Promise<Either<B, A>>`. This
 * thunk makes it a performant but lazy operation at the expense of stack
 * safety.
 *
 * @module AsyncEither
 * @since 2.0.0
 */
import "./_dnt.polyfills.js";
import type { Kind, Out } from "./kind.js";
import type { Applicable } from "./applicable.js";
import type { Async } from "./async.js";
import type { Bimappable } from "./bimappable.js";
import type { Combinable } from "./combinable.js";
import type { Either } from "./either.js";
import type { Failable } from "./failable.js";
import type { Flatmappable } from "./flatmappable.js";
import type { Initializable } from "./initializable.js";
import type { Mappable } from "./mappable.js";
import type { Wrappable } from "./wrappable.js";
/**
 * The AsyncEither type can best be thought of as an asynchronous function that
 * returns an `Either`. ie. `async () => Promise<Either<B, A>>`. This
 * forms the basis of most Promise based asynchronous communication in
 * TypeScript.
 *
 * @since 2.0.0
 */
export type AsyncEither<L, R> = Async<Either<L, R>>;
/**
 * Specifies AsyncEither as a Higher Kinded Type, with covariant
 * parameter A corresponding to the 0th index of any substitutions and covariant
 * parameter B corresponding to the 1st index of any substitutions.
 *
 * @since 2.0.0
 */
export interface KindAsyncEither extends Kind {
    readonly kind: AsyncEither<Out<this, 1>, Out<this, 0>>;
}
/**
 * Constructs a AsyncEither from a value and wraps it in an inner *Left*
 * traditionally signaling a failure.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 *
 * const left = AE.left(1);
 *
 * const result = await left(); // Left(1);
 * ```
 *
 * @since 2.0.0
 */
export declare function left<B, A = never>(left: B): AsyncEither<B, A>;
/**
 * Constructs a AsyncEither from a value and wraps it in an inner *Right*
 * traditionally signaling a successful computation.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 *
 * const right = AE.right(1);
 *
 * const result = await right(); // Right(1)
 * ```
 *
 * @since 2.0.0
 */
export declare function right<A = never, B = never>(right: A): AsyncEither<B, A>;
/**
 * Wraps a Async of A in a try-catch block which upon failure returns B instead.
 * Upon success returns a *Right<A>* and *Left<B>* for a failure.
 *
 * @example
 * ```ts
 * import * as TE from "./async_either.ts";
 * import * as E from "./either.ts";
 *
 * const tryFetch = TE.tryCatch(
 *   fetch,
 *   (error, args) => ({ message: "Fetch Error", error, args })
 * );
 *
 * const result1 = await tryFetch("blah")(); // Left(ErrorStruct)
 * const result2 = await tryFetch("https://deno.land/")(); // Right(*Deno Website*)
 * ```
 *
 * @since 2.0.0
 */
export declare function tryCatch<AS extends unknown[], A, B>(fasr: (...as: AS) => A | PromiseLike<A>, onThrow: (e: unknown, as: AS) => B): (...as: AS) => AsyncEither<B, A>;
/**
 * Lift an always succeeding async computation (Async) into a AsyncEither.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 * import * as A from "./async.ts";
 *
 * const value = AE.fromAsync(A.wrap(1));
 *
 * const result1 = await value(); // Right(1)
 * ```
 *
 * @since 2.0.0
 */
export declare function fromAsync<A, B = never>(ta: Async<A>): AsyncEither<B, A>;
/**
 * Lifts an Either<B,A> into a AsyncEither<B, A>.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 * import * as E from "./either.ts";
 *
 * const value1 = AE.fromEither(E.right(1));
 * const value2 = AE.fromEither(E.left("Error!"));
 *
 * const result1 = await value1(); // Right(1)
 * const result2 = await value2(); // Left("Error!")
 * ```
 *
 * @since 2.0.0
 */
export declare function fromEither<A, B>(ta: Either<B, A>): AsyncEither<B, A>;
/**
 * Construct an AsyncEither<B, A> from a value A.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 *
 * const value = AE.wrap(1);
 *
 * const result = await value(); // Right(1)
 * ```
 *
 * @since 2.0.0
 */
export declare function wrap<A, B = never>(a: A): AsyncEither<B, A>;
/**
 * Construct an AsyncEither<B, A> from a value B.
 *
 * @example
 * ```ts
 * import * as AE from "./async_either.ts";
 *
 * const value = AE.fail("Error!");
 *
 * const result = await value(); // Left("Error!");
 * ```
 *
 * @since 2.0.0
 */
export declare function fail<A = never, B = never>(b: B): AsyncEither<B, A>;
/**
 * Map a function over the *Right* side of a AsyncEither
 *
 * @since 2.0.0
 */
export declare function map<A, I>(fai: (a: A) => I): <B>(ta: AsyncEither<B, A>) => AsyncEither<B, I>;
/**
 * Map a function over the *Left* side of a AsyncEither
 *
 * @since 2.0.0
 */
export declare function mapSecond<B, J>(fbj: (b: B) => J): <A>(ta: AsyncEither<B, A>) => AsyncEither<J, A>;
/**
 * Apply an argument to a function under the *Right* side.
 *
 * @since 2.0.0
 */
export declare function apply<A, B>(ua: AsyncEither<B, A>): <I, J>(ufai: AsyncEither<J, (a: A) => I>) => AsyncEither<B | J, I>;
/**
 * Sequentially apply arguments
 *
 * @since 2.0.0
 */
export declare function applySequential<A, B>(ua: AsyncEither<B, A>): <I, J = never>(ufai: AsyncEither<J, (a: A) => I>) => AsyncEither<B | J, I>;
/**
 * Chain AsyncEither based computations together in a pipeline
 *
 * ```ts
 * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
 * import * as TE from "./async_either.ts";
 * import * as E from "./either.ts";
 * import { pipe } from "./fn.ts";
 *
 * const ta = pipe(
 *   TE.wrap(1),
 *   TE.flatmap(n => TE.wrap(n*2)),
 *   TE.flatmap(n => TE.wrap(n**2))
 * )
 *
 * assertEquals(await ta(), E.right(4))
 * ```
 *
 * @since 2.0.0
 */
export declare function flatmap<A, I, J>(fati: (a: A) => AsyncEither<J, I>): <B>(ta: AsyncEither<B, A>) => AsyncEither<B | J, I>;
/**
 * @since 2.0.0
 */
export declare function flatmapFirst<A, I, J>(fati: (a: A) => AsyncEither<J, I>): <B>(ta: AsyncEither<B, A>) => AsyncEither<B | J, A>;
/**
 * Chain AsyncEither based failures, *Left* sides, useful for recovering
 * from error conditions.
 *
 * ```ts
 * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
 * import * as TE from "./async_either.ts";
 * import * as E from "./either.ts";
 * import { pipe } from "./fn.ts";
 *
 * const ta = pipe(
 *   TE.fail(1),
 *   TE.recover(n => TE.wrap(n*2)),
 *   TE.flatmap(n => TE.wrap(n**2))
 * )
 *
 * assertEquals(await ta(), E.right(4))
 * ```
 *
 * @since 2.0.0
 */
export declare function recover<B, J, I>(fbtj: (b: B) => AsyncEither<J, I>): <A>(ta: AsyncEither<B, A>) => AsyncEither<J, A | I>;
/**
 * Provide an alternative for a failed computation.
 * Useful for implementing defaults.
 *
 * ```ts
 * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
 * import * as TE from "./async_either.ts";
 * import * as E from "./either.ts";
 * import { pipe } from "./fn.ts";
 *
 * const ta = pipe(
 *   TE.fail(1),
 *   TE.alt(TE.wrap(2)),
 * )
 *
 * assertEquals(await ta(), E.right(2))
 * ```
 *
 * @since 2.0.0
 */
export declare function alt<I, J>(ti: AsyncEither<J, I>): <A, B>(ta: AsyncEither<B, A>) => AsyncEither<B | J, A | I>;
/**
 * Fold away the inner Either from the `AsyncEither` leaving us with the
 * result of our computation in the form of a `Async`
 *
 * @since 2.0.0
 */
export declare function match<L = unknown, R = unknown, B = never>(onLeft: (left: L) => B, onRight: (right: R) => B): (ta: AsyncEither<L, R>) => Async<B>;
/**
 * @since 2.0.0
 */
export declare function getCombinableAsyncEither<A, B>(CA: Combinable<A>, CB: Combinable<B>): Combinable<AsyncEither<B, A>>;
/**
 * @since 2.0.0
 */
export declare function getInitializableAsyncEither<A, B>(CA: Initializable<A>, CB: Initializable<B>): Initializable<AsyncEither<B, A>>;
/**
 * @since 2.0.0
 */
export declare const ApplicableAsyncEither: Applicable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const BimappableAsyncEither: Bimappable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const FlatmappableAsyncEitherParallel: Flatmappable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const FlatmappableAsyncEitherSequential: Flatmappable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const FailableAsyncEitherParallel: Failable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const FailableAsyncEitherSequential: Failable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const MappableAsyncEither: Mappable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const WrappableAsyncEither: Wrappable<KindAsyncEither>;
/**
 * @since 2.0.0
 */
export declare const tap: <A>(fn: (value: A) => void) => <B = never, C = never, D = unknown, E = unknown>(ua: AsyncEither<B, A>) => AsyncEither<B, A>;
/**
 * @since 2.0.0
 */
export declare const bind: <N extends string, A, I, J = never, K = never, L = unknown, M = unknown>(name: Exclude<N, keyof A>, faui: (a: A) => AsyncEither<J, I>) => <B = never, C = never, D extends L = L>(ua: AsyncEither<B, A>) => AsyncEither<J | B, { readonly [K_1 in N | keyof A]: K_1 extends keyof A ? A[K_1] : I; }>;
/**
 * @since 2.0.0
 */
export declare const bindTo: <N extends string>(name: N) => <A, B = never, C = never, D = unknown, E = unknown>(ua: AsyncEither<B, A>) => AsyncEither<B, { readonly [K in N]: A; }>;