export type Left<E> = Readonly<{
    isRight: false;
    left: E;
}>;
export type Right<A> = Readonly<{
    isRight: true;
    right: A;
}>;
/**
 * A value of `Either` type `Left<E>` or type `Right<A>`; a disjoint union.
 *
 * A common use case is as an alternative to `Option` where `Left<E>` contains useful
 * information. Convention dictates that `Left<E>` is used for failure and `Right<A>` for success.
 * To help remember, the success case is "right"; it's the result you want.
 *
 * @example
 * <embedex source="packages/util-ts/examples/either.ts">
 *
 * ```ts
 * import { strictEqual } from "node:assert/strict";
 *
 * import { either as E, pipe } from "@clipboard-health/util-ts";
 *
 * function double(n: number): number {
 *   return n * 2;
 * }
 *
 * function inverse(n: number): E.Either<string, number> {
 *   return n === 0 ? E.left("Division by zero") : E.right(1 / n);
 * }
 *
 * const result = pipe(
 *   E.right(5),
 *   E.map(double),
 *   E.flatMap(inverse),
 *   E.match(
 *     (error) => `Error: ${error}`,
 *     (r) => `Result is ${r}`,
 *   ),
 * );
 *
 * strictEqual(result, "Result is 0.1");
 * ```
 *
 * </embedex>
 */
export type Either<E, A> = Left<E> | Right<A>;
/**
 * Constructs an `Either` holding a `Left<E>` value, usually representing a failure.
 *
 * @param value - The value to wrap in a `Left`
 * @returns A `Left` containing the value
 */
export declare function left<E, A = never>(value: E): Either<E, A>;
/**
 * Constructs an `Either` holding a `Right<A>`, representing a success.
 *
 * @param value - The value to wrap in a `Right`
 * @returns A `Right` containing the value
 */
export declare function right<A, E = never>(value: A): Either<E, A>;
/**
 * Type guard that checks if an either is `Left<E>`.
 *
 * @param either - The `Either` to check
 * @returns `true` if the `Either` is `Left<E>`, `false` if it is `Right<A>`
 */
export declare function isLeft<E, A>(either: Either<E, A>): either is Left<E>;
/**
 * Type guard that checks if an either is `Right<A>`.
 *
 * @param either - The `Either` to check
 * @returns `true` if the `Either` is `Right<A>`, `false` if it is `Left<E>`
 */
export declare function isRight<E, A>(either: Either<E, A>): either is Right<A>;
/**
 * Transforms the value inside an `Either` using the provided function. If the `Either` is
 * `Right(value)`, returns `Right(f(value))`. If the `Either` is `Left(value)`, returns
 * `Left(value)`.
 *
 * @param f - The function to apply to the `Right` value
 * @returns A function that transforms `Either<E, A>` to `Either<E, B>`
 */
export declare function map<A, B>(f: (right: A) => B): <E>(either: Either<E, A>) => Either<E, B>;
/**
 * Transforms the value inside an `Either` using the provided function. If the `Either` is
 * `Left(value)`, returns `Left(f(value))`. If the `Either` is `Right(value)`, returns
 * `Right(value)`.
 */
export declare function mapLeft<E, G>(f: (left: E) => G): <A>(either: Either<E, A>) => Either<G, A>;
/**
 * Chains `Either` operations that return `Either`s. Unlike `map` which wraps the result in a new
 * `Either`, `flatMap` prevents nested `Either`s like `Right(Right(value))`.
 *
 * @param f - A function that returns an `Either`
 * @returns The `Either` returned by the function if the input is `Right`, `Left` otherwise
 */
export declare function flatMap<E, A, B>(f: (right: A) => Either<E, B>): (either: Either<E, A>) => Either<E, B>;
/**
 * Safely extracts the value from an `Either` with a fallback. Use this function when you need to
 * convert an `Either<E, A>` to an `A`, providing a default value for the `Left` case.
 *
 * @param onLeft - The value to return if the `Either` is `Left`
 * @returns The contained value if `Right`, the result of `onLeft` if `Left`
 */
export declare function getOrElse<E, A>(onLeft: (left: E) => A): (either: Either<E, A>) => A;
/**
 * Pattern matches on an `Either`, handling both `Right` and `Left` cases.
 *
 * @param onLeft - Function to handle the `Left` case
 * @param onRight - Function to handle the `Right` case
 * @returns The result of either `onLeft` or `onRight` based on the `Either` state
 */
export declare function match<E, A, B, C>(onLeft: (left: E) => B, onRight: (right: A) => C): (either: Either<E, A>) => B | C;