/**
 * adapted from https://github.com/gcanti/fp-ts
 */
import { HKT } from "@tsplus/stdlib/prelude/HKT";
import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
/**
 * @tsplus type Either
 */
export type Either<E, A> = Left<E> | Right<A>;
export interface EitherF extends HKT {
    readonly type: Either<this["E"], this["A"]>;
}
export interface EitherFixedLeftF<E> extends HKT {
    readonly type: HKT.Kind<EitherF, this["R"], E, this["A"]>;
}
/**
 * @tsplus type Either.Ops
 */
export interface EitherOps {
    $: EitherAspects;
}
export declare const Either: EitherOps;
/**
 * @tsplus type Either.Aspects
 */
export interface EitherAspects {
}
export declare namespace Either {
    type HKT = EitherF;
    type FixedLeftHKT<E> = EitherFixedLeftF<E>;
}
/**
 * @tsplus type Either.Left
 */
export interface Left<E> {
    readonly _tag: "Left";
    readonly left: E;
}
/**
 * @tsplus type Either.Right
 */
export interface Right<A> {
    readonly _tag: "Right";
    readonly right: A;
}
/**
 * @tsplus unify Either
 * @tsplus unify Either.Left
 * @tsplus unify Either.Right
 */
export declare function unifyEither<X extends Either<any, any>>(self: X): Either<X extends Left<infer EX> ? EX : never, X extends Right<infer AX> ? AX : never>;
/**
 * Returns `true` if the `Either` is an instance of `Left`, `false` otherwise.
 * @tsplus fluent Either isLeft
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function isLeft<E, A>(ma: Either<E, A>): ma is Left<E>;
/**
 * Returns `true` if the `Either` is an instance of `Right`, `false` otherwise.
 * @tsplus fluent Either isRight
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function isRight<E, A>(ma: Either<E, A>): ma is Right<A>;
/**
 * @tsplus getter Either left
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function getLeft<E, A>(self: Either<E, A>): Maybe<E>;
/**
 * @tsplus static Either.Ops isEither
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function isEither(u: unknown): u is Either<unknown, unknown>;
/**
 * @tsplus getter Either right
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
/**
 * Constructs a new `Either` holding a `Right` value. This usually represents a
 * successful value due to the right bias of this structure.
 * @tsplus static Either.Ops right
 * @tsplus static Either.Ops __call
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function right<A>(a: A): Either<never, A>;
/**
 * Constructs a new `Either` holding a `Right` value. This usually represents a
 * successful value due to the right bias of this structure.
 * @tsplus static Either.Ops rightW
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function rightW<A, E = never>(a: A): Either<E, A>;
/**
 * Constructs a new `Either` holding a `Left` value. This usually represents a
 * failure, due to the right-bias of this structure.
 * @tsplus static Either.Ops left
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function left<E>(e: E): Either<E, never>;
/**
 * Constructs a new `Either` holding a `Left` value. This usually represents a
 * failure, due to the right-bias of this structure.
 * @tsplus static Either.Ops leftW
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function leftW<E, A = never>(e: E): Either<E, A>;
/**
 * Widen left side `Either[E, A] => Either[E | E1, A]`.
 * @tsplus getter Either widenE
 * @tsplus macro identity
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function widenE_<E, A, E1>(self: Either<E, A>): Either<E | E1, A>;
/**
 * Widen left side `Either[E, A] => Either[E | E1, A]`.
 * @tsplus static Either.Aspects widenE
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function widenE<E1>(): <E, A>(self: Either<E, A>) => Either<E1 | E, A>;
/**
 * Widen left side `Either[E, A] => Either[E | E1, A]`.
 * @tsplus getter Either widenA
 * @tsplus macro identity
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function widenA_<E, A, A1>(self: Either<E, A>): Either<E, A | A1>;
/**
 * Widen right side `Either[E, A] => Either[E, A | A1]`.
 * @tsplus static Either.Aspects widenA
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function widenA<A1>(): <E, A>(self: Either<E, A>) => Either<E, A1 | A>;
/**
 * @tsplus operator Either ==
 * @tsplus location "@tsplus/stdlib/data/Either/definition"
 */
export declare function equals<E, A, E1, B>(a: Either<E, A>, b: Either<E1, B>): boolean;
//# sourceMappingURL=definition.d.ts.map