/**
 * @since 1.0.0
 */
import type { Either, Left, Right } from "@fp-ts/core/Either";
import type { LazyArg } from "@fp-ts/core/Function";
import type { Kind, TypeLambda } from "@fp-ts/core/HKT";
import * as O from "@fp-ts/core/Option";
import type { Option } from "@fp-ts/core/Option";
import type { Predicate, Refinement } from "@fp-ts/core/Predicate";
import type { NonEmptyReadonlyArray } from "@fp-ts/core/ReadonlyArray";
import * as applicative from "@fp-ts/core/typeclass/Applicative";
import * as bicovariant from "@fp-ts/core/typeclass/Bicovariant";
import * as chainable from "@fp-ts/core/typeclass/Chainable";
import * as covariant from "@fp-ts/core/typeclass/Covariant";
import type { Equivalence } from "@fp-ts/core/typeclass/Equivalence";
import * as flatMap_ from "@fp-ts/core/typeclass/FlatMap";
import type * as foldable from "@fp-ts/core/typeclass/Foldable";
import * as invariant from "@fp-ts/core/typeclass/Invariant";
import type * as monad from "@fp-ts/core/typeclass/Monad";
import type { Monoid } from "@fp-ts/core/typeclass/Monoid";
import * as of_ from "@fp-ts/core/typeclass/Of";
import type * as pointed from "@fp-ts/core/typeclass/Pointed";
import * as product_ from "@fp-ts/core/typeclass/Product";
import type * as semiAlternative from "@fp-ts/core/typeclass/SemiAlternative";
import * as semiApplicative from "@fp-ts/core/typeclass/SemiApplicative";
import * as semiCoproduct from "@fp-ts/core/typeclass/SemiCoproduct";
import type { Semigroup } from "@fp-ts/core/typeclass/Semigroup";
import * as semiProduct from "@fp-ts/core/typeclass/SemiProduct";
import * as traversable from "@fp-ts/core/typeclass/Traversable";
/**
 * @category model
 * @since 1.0.0
 */
export interface Both<E, A> {
    readonly _tag: "Both";
    readonly left: E;
    readonly right: A;
}
/**
 * @category model
 * @since 1.0.0
 */
export type These<E, A> = Either<E, A> | Both<E, A>;
/**
 * @category model
 * @since 1.0.0
 */
export type Validated<E, A> = These<NonEmptyReadonlyArray<E>, A>;
/**
 * @category type lambdas
 * @since 1.0.0
 */
export interface TheseTypeLambda extends TypeLambda {
    readonly type: These<this["Out1"], this["Target"]>;
}
/**
 * @category type lambdas
 * @since 3.0.0
 */
export interface ValidatedTypeLambda extends TypeLambda {
    readonly type: Validated<this["Out1"], this["Target"]>;
}
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const left: <E>(left: E) => These<E, never>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const right: <A>(right: A) => These<never, A>;
/**
 * Alias of {@link right}.
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const of: <A>(right: A) => These<never, A>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const both: <E, A>(left: E, right: A) => These<E, A>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const leftOrBoth: {
    <E>(onSome: LazyArg<E>): <A>(self: Option<A>) => These<E, A>;
    <A, E>(self: Option<A>, onSome: LazyArg<E>): These<E, A>;
};
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const rightOrBoth: {
    <A>(onNone: LazyArg<A>): <E>(self: Option<E>) => These<E, A>;
    <E, A>(self: Option<E>, onNone: LazyArg<A>): These<E, A>;
};
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const fail: <E>(e: E) => Validated<E, never>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const warn: <E, A>(e: E, a: A) => Validated<E, A>;
/**
 * @category equivalence
 * @since 1.0.0
 */
export declare const getEquivalence: <E, A>(EE: Equivalence<E>, EA: Equivalence<A>) => Equivalence<These<E, A>>;
/**
 * @category pattern matching
 * @since 1.0.0
 */
export declare const match: {
    <E, B, A, C = B, D = B>(onLeft: (e: E) => B, onRight: (a: A) => C, onBoth: (e: E, a: A) => D): (self: These<E, A>) => B | C | D;
    <E, B, A, C = B, D = B>(self: These<E, A>, onLeft: (e: E) => B, onRight: (a: A) => C, onBoth: (e: E, a: A) => D): B | C | D;
};
/**
 * @since 1.0.0
 */
export declare const reverse: <E, A>(self: These<E, A>) => These<A, E>;
/**
 * Tests if a value is a `These`.
 *
 * @param input - The value to check.
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isThese: (input: unknown) => input is These<unknown, unknown>;
/**
 * Determine if a `These` is a `Left`.
 *
 * @param self - The `These` to check.
 *
 * @example
 * import { isLeft, left, right, both } from '@fp-ts/core/These'
 *
 * assert.deepStrictEqual(isLeft(right(1)), false)
 * assert.deepStrictEqual(isLeft(left("error")), true)
 * assert.deepStrictEqual(isLeft(both("error", 1)), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isLeft: <E, A>(self: These<E, A>) => self is Left<E>;
/**
 * Determine if a `These` is a `Left` or a `Both`.
 *
 * @param self - The `These` to check.
 *
 * @example
 * import { isLeftOrBoth, left, right, both } from '@fp-ts/core/These'
 *
 * assert.deepStrictEqual(isLeftOrBoth(right(1)), false)
 * assert.deepStrictEqual(isLeftOrBoth(left("error")), true)
 * assert.deepStrictEqual(isLeftOrBoth(both("error", 1)), true)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isLeftOrBoth: <E, A>(self: These<E, A>) => self is Left<E> | Both<E, A>;
/**
 * Determine if a `These` is a `Right`.
 *
 * @param self - The `These` to check.
 *
 * @example
 * import { isRight, left, right, both } from '@fp-ts/core/These'
 *
 * assert.deepStrictEqual(isRight(right(1)), true)
 * assert.deepStrictEqual(isRight(left("error")), false)
 * assert.deepStrictEqual(isRight(both("error", 1)), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isRight: <E, A>(self: These<E, A>) => self is Right<A>;
/**
 * Determine if a `These` is a `Right` or a `Both`.
 *
 * @param self - The `These` to check.
 *
 * @example
 * import { isRightOrBoth, left, right, both } from '@fp-ts/core/These'
 *
 * assert.deepStrictEqual(isRightOrBoth(right(1)), true)
 * assert.deepStrictEqual(isRightOrBoth(left("error")), false)
 * assert.deepStrictEqual(isRightOrBoth(both("error", 1)), true)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isRightOrBoth: <E, A>(self: These<E, A>) => self is Right<A> | Both<E, A>;
/**
 * Determine if a `These` is a `Both`.
 *
 * @param self - The `These` to check.
 *
 * @example
 * import { isBoth, left, right, both } from '@fp-ts/core/These'
 *
 * assert.deepStrictEqual(isBoth(right(1)), false)
 * assert.deepStrictEqual(isBoth(left("error")), false)
 * assert.deepStrictEqual(isBoth(both("error", 1)), true)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isBoth: <E, A>(self: These<E, A>) => self is Both<E, A>;
/**
 * Lifts a function that may throw to one returning a `These`.
 *
 * @category interop
 * @since 1.0.0
 */
export declare const liftThrowable: <A extends ReadonlyArray<unknown>, B, E>(f: (...a: A) => B, onThrow: (error: unknown) => E) => ((...a: A) => These<E, B>);
/**
 * Extracts the value of a `These` or throws if the `These` is `Left`.
 *
 * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
 *
 * @param self - The `These` to extract the value from.
 * @param onLeft - A function that will be called if the `These` is `Left`. It returns the error to be thrown.
 *
 * @example
 * import * as E from "@fp-ts/core/These"
 *
 * assert.deepStrictEqual(
 *   E.getOrThrowWith(E.right(1), () => new Error('Unexpected Left')),
 *   1
 * )
 * assert.deepStrictEqual(
 *   E.getOrThrowWith(E.both("warning", 1), () => new Error('Unexpected Left')),
 *   1
 * )
 * assert.throws(() => E.getOrThrowWith(E.left("error"), () => new Error('Unexpected Left')))
 *
 * @category interop
 * @since 1.0.0
 */
export declare const getOrThrowWith: {
    <E>(onLeft: (e: E) => unknown): <A>(self: These<E, A>) => A;
    <E, A>(self: These<E, A>, onLeft: (e: E) => unknown): A;
};
/**
 * Extracts the value of a `These` or throws if the `These` is `Left`.
 *
 * The thrown error is a default error. To configure the error thrown, see {@link getOrThrowWith}.
 *
 * @param self - The `These` to extract the value from.
 * @throws `Error("getOrThrow called on a Left")`
 *
 * @example
 * import * as T from "@fp-ts/core/These"
 *
 * assert.deepStrictEqual(T.getOrThrow(T.right(1)), 1)
 * assert.deepStrictEqual(T.getOrThrow(T.both("warning", 1)), 1)
 * assert.throws(() => T.getOrThrow(T.left("error")))
 *
 * @category interop
 * @since 1.0.0
 */
export declare const getOrThrow: <E, A>(self: These<E, A>) => A;
/**
 * Extracts the value of a `These` or throws if the `These` is `Left`.
 *
 * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
 *
 * @param self - The `These` to extract the value from.
 * @param onLeft - A function that will be called if the `These` is `Left`. It returns the error to be thrown.
 *
 * @example
 * import * as E from "@fp-ts/core/These"
 *
 * assert.deepStrictEqual(
 *   E.getRightOnlyOrThrowWith(
 *     E.right(1),
 *     () => new Error("Unexpected Left or Both")
 *   ),
 *   1
 * )
 * assert.throws(() => E.getRightOnlyOrThrowWith(E.both("warning", 1), () => new Error("Unexpected Left or Both")))
 * assert.throws(() => E.getRightOnlyOrThrowWith(E.left("error"), () => new Error("Unexpected Left or Both")))
 *
 * @category interop
 * @since 1.0.0
 */
export declare const getRightOnlyOrThrowWith: {
    <E>(onLeftOrBoth: (e: E) => unknown): <A>(self: These<E, A>) => A;
    <E, A>(self: These<E, A>, onLeftOrBoth: (e: E) => unknown): A;
};
/**
 * Extracts the value of a `These` or throws if the `These` is not a `Right`.
 *
 * The thrown error is a default error. To configure the error thrown, see {@link getRightOnlyOrThrowWith}.
 *
 * @param self - The `These` to extract the value from.
 * @throws `Error("getOrThrow called on a Left")`
 *
 * @example
 * import * as T from "@fp-ts/core/These"
 *
 * assert.deepStrictEqual(T.getRightOnlyOrThrow(T.right(1)), 1)
 * assert.throws(() => T.getRightOnlyOrThrow(T.both("error", 1)))
 * assert.throws(() => T.getRightOnlyOrThrow(T.left("error")))
 *
 * @category interop
 * @since 1.0.0
 */
export declare const getRightOnlyOrThrow: <E, A>(self: These<E, A>) => A;
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const fromNullable: {
    <E>(onNullable: LazyArg<E>): <A>(a: A) => These<E, NonNullable<A>>;
    <A, E>(a: A, onNullable: LazyArg<E>): These<E, NonNullable<A>>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const fromEither: <E, A>(self: Either<E, A>) => Validated<E, A>;
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const toEither: {
    <E, A>(onBoth: (e: E, a: A) => Either<E, A>): (self: These<E, A>) => Either<E, A>;
    <E, A>(self: These<E, A>, onBoth: (e: E, a: A) => Either<E, A>): Either<E, A>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const absolve: <E, A>(self: These<E, A>) => Either<E, A>;
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const condemn: <E, A>(self: These<E, A>) => Either<E, A>;
/**
 * @category lifting
 * @since 1.0.0
 */
export declare const liftNullable: <A extends readonly unknown[], B, E>(f: (...a: A) => B | null | undefined, onNullable: (...a: A) => E) => (...a: A) => These<E, NonNullable<B>>;
/**
 * @category sequencing
 * @since 1.0.0
 */
export declare const flatMapNullable: {
    <A, B, E2>(f: (a: A) => B | null | undefined, onNullable: (a: A) => E2): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, NonNullable<B>>;
    <E1, A, B, E2>(self: Validated<E1, A>, f: (a: A) => B | null | undefined, onNullable: (a: A) => E2): Validated<E1 | E2, NonNullable<B>>;
};
/**
 * @category lifting
 * @since 1.0.0
 */
export declare const liftPredicate: {
    <C extends A, B extends A, E, A = C>(refinement: Refinement<A, B>, onFalse: (c: C) => E): (c: C) => These<E, B>;
    <B extends A, E, A = B>(predicate: Predicate<A>, onFalse: (b: B) => E): (b: B) => These<E, B>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const fromIterable: {
    <E>(onEmpty: LazyArg<E>): <A>(collection: Iterable<A>) => These<E, A>;
    <A, E>(collection: Iterable<A>, onEmpty: LazyArg<E>): These<E, A>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const fromOption: {
    <E>(onNone: LazyArg<E>): <A>(self: Option<A>) => These<E, A>;
    <A, E>(self: Option<A>, onNone: LazyArg<E>): These<E, A>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const fromTuple: <E, A>(self: readonly [E, A]) => These<E, A>;
/**
 * @category lifting
 * @since 1.0.0
 */
export declare const liftOption: <A extends readonly unknown[], B, E>(f: (...a: A) => O.Option<B>, onNone: (...a: A) => E) => (...a: A) => These<E, B>;
/**
 * @category lifting
 * @since 1.0.0
 */
export declare const liftEither: <A extends readonly unknown[], E, B>(f: (...a: A) => Either<E, B>) => (...a: A) => Validated<E, B>;
/**
 * @category lifting
 * @since 1.0.0
 */
export declare const liftThese: <A extends readonly unknown[], E, B>(f: (...a: A) => These<E, B>) => (...a: A) => Validated<E, B>;
/**
 * @category sequencing
 * @since 1.0.0
 */
export declare const flatMapOption: {
    <A, B, E2>(f: (a: A) => Option<B>, onNone: (a: A) => E2): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, B>;
    <E1, A, B, E2>(self: Validated<E1, A>, f: (a: A) => Option<B>, onNone: (a: A) => E2): Validated<E1 | E2, B>;
};
/**
 * @category sequencing
 * @since 1.0.0
 */
export declare const flatMapEither: {
    <A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, B>;
    <E1, A, E2, B>(self: Validated<E1, A>, f: (a: A) => Either<E2, B>): Validated<E1 | E2, B>;
};
/**
 * @category sequencing
 * @since 1.0.0
 */
export declare const flatMapThese: {
    <A, E2, B>(f: (a: A) => These<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, B>;
    <E1, A, E2, B>(self: Validated<E1, A>, f: (a: A) => These<E2, B>): Validated<E1 | E2, B>;
};
/**
 * Converts a `These` to an `Option` discarding the error (`Both` included).
 *
 * @category getters
 * @since 1.0.0
 */
export declare const getRight: <E, A>(self: These<E, A>) => O.Option<A>;
/**
 * Returns the value if and only if the value is a `Right` (i.e. `Both` is excluded).
 *
 * @category getters
 * @since 1.0.0
 */
export declare const getRightOnly: <E, A>(self: These<E, A>) => O.Option<A>;
/**
 * Converts a `These` to an `Option` discarding the value (`Both` included).
 *
 * @category getters
 * @since 1.0.0
 */
export declare const getLeft: <E, A>(self: These<E, A>) => O.Option<E>;
/**
 * Returns the error if and only if the value is a `Left` (i.e. `Both` is excluded).
 *
 * @category getters
 * @since 1.0.0
 */
export declare const getLeftOnly: <E, A>(self: These<E, A>) => O.Option<E>;
/**
 * @category getters
 * @since 1.0.0
 */
export declare const getBoth: <E, A>(self: These<E, A>) => O.Option<readonly [E, A]>;
/**
 * @category getters
 * @since 1.0.0
 */
export declare const getBothOrElse: {
    <E, A>(e: LazyArg<E>, a: LazyArg<A>): (self: These<E, A>) => [E, A];
    <E, A>(self: These<E, A>, e: LazyArg<E>, a: LazyArg<A>): [E, A];
};
/**
 * @category getters
 * @since 1.0.0
 */
export declare const getOrElse: {
    <B>(onLeft: LazyArg<B>): <E, A>(self: These<E, A>) => A | B;
    <E, A, B>(self: These<E, A>, onLeft: LazyArg<B>): A | B;
};
/**
 * @category getters
 * @since 1.0.0
 */
export declare const getOrNull: <E, A>(self: These<E, A>) => A | null;
/**
 * @category getters
 * @since 1.0.0
 */
export declare const getOrUndefined: <E, A>(self: These<E, A>) => A | undefined;
/**
 * @category debugging
 * @since 1.0.0
 */
export declare const inspectRight: {
    <A>(onRight: (a: A) => void): <E>(self: These<E, A>) => These<E, A>;
    <E, A>(self: These<E, A>, onRight: (a: A) => void): These<E, A>;
};
/**
 * @category debugging
 * @since 1.0.0
 */
export declare const inspectRightOrBoth: {
    <A>(onRightOrBoth: (a: A) => void): <E>(self: These<E, A>) => These<E, A>;
    <E, A>(self: These<E, A>, onRightOrBoth: (a: A) => void): These<E, A>;
};
/**
 * @category debugging
 * @since 1.0.0
 */
export declare const inspectLeft: {
    <E>(onLeft: (e: E) => void): <A>(self: These<E, A>) => These<E, A>;
    <E, A>(self: These<E, A>, onLeft: (e: E) => void): These<E, A>;
};
/**
 * @category debugging
 * @since 1.0.0
 */
export declare const inspectBoth: {
    <E, A>(onBoth: (e: E, a: A) => void): (self: These<E, A>) => These<E, A>;
    <E, A>(self: These<E, A>, onBoth: (e: E, a: A) => void): These<E, A>;
};
/**
 * @category mapping
 * @since 1.0.0
 */
export declare const bimap: {
    <E1, E2, A, B>(f: (e: E1) => E2, g: (a: A) => B): (self: These<E1, A>) => These<E2, B>;
    <E1, A, E2, B>(self: These<E1, A>, f: (e: E1) => E2, g: (a: A) => B): These<E2, B>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Bicovariant: bicovariant.Bicovariant<TheseTypeLambda>;
/**
 * Maps the `Left` side of an `These` value to a new `These` value.
 *
 * @param self - The input `These` value to map.
 * @param f - A transformation function to apply to the `Left` value of the input `These`.
 *
 * @category error handling
 * @since 1.0.0
 */
export declare const mapLeft: {
    <E, G>(f: (e: E) => G): <A>(self: These<E, A>) => These<G, A>;
    <E, A, G>(self: These<E, A>, f: (e: E) => G): These<G, A>;
};
/**
 * @category conversions
 * @since 1.0.0
 */
export declare const toValidated: <E, A>(self: These<E, A>) => Validated<E, A>;
/**
 * Maps the `Right` side of an `These` value to a new `These` value.
 *
 * @param self - An `These` to map
 * @param f - The function to map over the value of the `These`
 *
 * @category mapping
 * @since 1.0.0
 */
export declare const map: {
    <E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B>;
    <A, B>(f: (a: A) => B): <E>(self: These<E, A>) => These<E, B>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Covariant: covariant.Covariant<TheseTypeLambda>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Invariant: invariant.Invariant<TheseTypeLambda>;
/**
 * @category mapping
 * @since 1.0.0
 */
export declare const tupled: <E, A>(self: These<E, A>) => These<E, [A]>;
/**
 * @category mapping
 * @since 1.0.0
 */
export declare const flap: {
    <A, E, B>(a: A, self: These<E, (a: A) => B>): These<E, B>;
    <E, A, B>(self: These<E, (a: A) => B>): (a: A) => These<E, B>;
};
/**
 * Maps the right value of this effect to the specified constant value.
 *
 * @category mapping
 * @since 1.0.0
 */
export declare const as: {
    <E, _, B>(self: These<E, _>, b: B): These<E, B>;
    <B>(b: B): <E, _>(self: These<E, _>) => These<E, B>;
};
/**
 * Returns the effect resulting from mapping the right of this effect to unit.
 *
 * @category mapping
 * @since 1.0.0
 */
export declare const asUnit: <E, _>(self: These<E, _>) => These<E, void>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Of: of_.Of<TheseTypeLambda>;
/**
 * @since 1.0.0
 */
export declare const unit: These<never, void>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Pointed: pointed.Pointed<TheseTypeLambda>;
/**
 * @category traversing
 * @since 1.0.0
 */
export declare const traverse: <F extends TypeLambda>(F: applicative.Applicative<F>) => {
    <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>): <TE>(self: These<TE, A>) => Kind<F, R, O, E, These<TE, B>>;
    <TE_1, A_1, R_1, O_1, E_1, B_1>(self: These<TE_1, A_1>, f: (a: A_1) => Kind<F, R_1, O_1, E_1, B_1>): Kind<F, R_1, O_1, E_1, These<TE_1, B_1>>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Traversable: traversable.Traversable<TheseTypeLambda>;
/**
 * @category traversing
 * @since 1.0.0
 */
export declare const sequence: <F extends TypeLambda>(F: applicative.Applicative<F>) => <TE, R, O, E, A>(self: These<TE, Kind<F, R, O, E, A>>) => Kind<F, R, O, E, These<TE, A>>;
/**
 * @category traversing
 * @since 1.0.0
 */
export declare const traverseTap: <F extends TypeLambda>(F: applicative.Applicative<F>) => {
    <TE, A, R, O, E, B>(self: These<TE, A>, f: (a: A) => Kind<F, R, O, E, B>): Kind<F, R, O, E, These<TE, A>>;
    <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>): <TE>(self: These<TE, A>) => Kind<F, R, O, E, These<TE, A>>;
};
/**
 * Returns a function that checks if a `These` contains a given value using a provided `equivalence` function.
 *
 * @since 1.0.0
 */
export declare const contains: <A>(isEquivalent: (self: A, that: A) => boolean) => {
    (a: A): <E>(self: These<E, A>) => boolean;
    <E_1>(self: These<E_1, A>, a: A): boolean;
};
/**
 * @category predicates
 * @since 1.0.0
 */
export declare const exists: {
    <A>(predicate: Predicate<A>): <E>(self: These<E, A>) => boolean;
    <E, A>(self: These<E, A>, predicate: Predicate<A>): boolean;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Foldable: foldable.Foldable<TheseTypeLambda>;
/**
 * Executes this effect and returns its value, if it succeeds, but otherwise
 * executes the specified effect.
 *
 * @category error handling
 * @since 1.0.0
 */
export declare const orElse: {
    <E1, E2, B>(that: (e1: E1) => These<E2, B>): <A>(self: These<E1, A>) => These<E1 | E2, A | B>;
    <E1, A, E2, B>(self: These<E1, A>, that: (e1: E1) => These<E2, B>): These<E1 | E2, A | B>;
};
/**
 * Returns an effect that will produce the value of this effect, unless it
 * fails, in which case, it will produce the value of the specified effect.
 *
 * @category error handling
 * @since 1.0.0
 */
export declare const orElseEither: {
    <E1, E2, B>(that: (e1: E1) => These<E2, B>): <A>(self: These<E1, A>) => These<E1 | E2, Either<A, B>>;
    <E1, A, E2, B>(self: These<E1, A>, that: (e1: E1) => These<E2, B>): These<E1 | E2, Either<A, B>>;
};
/**
 * Executes this effect and returns its value, if it succeeds, but otherwise
 * fails with the specified error.
 *
 * @category error handling
 * @since 1.0.0
 */
export declare const orElseFail: {
    <E2>(onLeft: LazyArg<E2>): <E1, A>(self: These<E1, A>) => These<E1 | E2, A>;
    <E1, A, E2>(self: These<E1, A>, onLeft: LazyArg<E2>): These<E1 | E2, A>;
};
/**
 * @category error handling
 * @since 1.0.0
 */
export declare const firstRightOrBothOf: {
    <E, A>(collection: Iterable<These<E, A>>): (self: These<E, A>) => These<E, A>;
    <E, A>(self: These<E, A>, collection: Iterable<These<E, A>>): These<E, A>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const SemiCoproduct: semiCoproduct.SemiCoproduct<TheseTypeLambda>;
/**
 * @category combining
 * @since 1.0.0
 */
export declare const getFirstRightOrBothSemigroup: <E, A>() => Semigroup<These<E, A>>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const SemiAlternative: semiAlternative.SemiAlternative<TheseTypeLambda>;
/**
 * @category filtering
 * @since 1.0.0
 */
export declare const filter: {
    <C extends A, B extends A, E2, A = C>(refinement: Refinement<A, B>, onFalse: LazyArg<E2>): <E1>(self: These<E1, C>) => These<E1 | E2, B>;
    <B extends A, E2, A = B>(predicate: Predicate<A>, onFalse: LazyArg<E2>): <E1>(self: These<E1, B>) => These<E1 | E2, B>;
    <E1, C extends A, B extends A, E2, A = C>(self: These<E1, C>, refinement: Refinement<A, B>, onFalse: LazyArg<E2>): These<E1 | E2, B>;
    <E1, B extends A, E2, A = B>(self: These<E1, B>, predicate: Predicate<A>, onFalse: LazyArg<E2>): These<E1 | E2, B>;
};
/**
 * @category filtering
 * @since 1.0.0
 */
export declare const filterMap: {
    <A, B, E2>(f: (a: A) => Option<B>, onNone: LazyArg<E2>): <E1>(self: These<E1, A>) => These<E1 | E2, B>;
    <E1, A, B, E2>(self: These<E1, A>, f: (a: A) => Option<B>, onNone: LazyArg<E2>): These<E1 | E2, B>;
};
/**
 * @category filtering
 * @since 1.0.0
 */
export declare const compact: {
    <E>(onNone: LazyArg<E>): <A>(self: These<E, Option<A>>) => These<E, A>;
    <E, A>(self: These<E, Option<A>>, onNone: LazyArg<E>): These<E, A>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const SemiProduct: semiProduct.SemiProduct<ValidatedTypeLambda>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const SemiApplicative: semiApplicative.SemiApplicative<ValidatedTypeLambda>;
/**
 * Lifts a binary function into `These`.
 *
 * @param f - The function to lift.
 *
 * @category lifting
 * @since 1.0.0
 */
export declare const lift2: <A, B, C>(f: (a: A, b: B) => C) => {
    <E1, E2>(self: Validated<E1, A>, that: Validated<E2, B>): Validated<E1 | E2, C>;
    <E2>(that: Validated<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E2 | E1, C>;
};
/**
 * @category combining
 * @since 1.0.0
 */
export declare const zipWith: {
    <E1, A, E2, B, C>(self: Validated<E1, A>, that: Validated<E2, B>, f: (a: A, b: B) => C): Validated<E1 | E2, C>;
    <E2, B, A, C>(that: Validated<E2, B>, f: (a: A, b: B) => C): <E1>(self: Validated<E1, A>) => Validated<E2 | E1, C>;
};
/**
 * @since 1.0.0
 */
export declare const ap: {
    <E1, A, B, E2>(self: Validated<E1, (a: A) => B>, that: Validated<E2, A>): Validated<E1 | E2, B>;
    <E2, A>(that: Validated<E2, A>): <E1, B>(self: Validated<E1, (a: A) => B>) => Validated<E2 | E1, B>;
};
/**
 * @category combining
 * @since 1.0.0
 */
export declare const getFirstLeftSemigroup: <A, E>(S: Semigroup<A>) => Semigroup<Validated<E, A>>;
/**
 * Appends an element to the end of a tuple.
 *
 * @since 1.0.0
 */
export declare const appendElement: {
    <E1, A extends ReadonlyArray<any>, E2, B>(self: Validated<E1, A>, that: Validated<E2, B>): Validated<E1 | E2, [...A, B]>;
    <E2, B>(that: Validated<E2, B>): <E1, A extends ReadonlyArray<any>>(self: Validated<E1, A>) => Validated<E2 | E1, [...A, B]>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Product: product_.Product<ValidatedTypeLambda>;
/**
 * @since 1.0.0
 */
export declare const tuple: <T extends ReadonlyArray<Validated<any, any>>>(...tuple: T) => Validated<[
    T[number]
] extends [Validated<infer E, any>] ? E : never, {
    [I in keyof T]: [T[I]] extends [Validated<any, infer A>] ? A : never;
}>;
/**
 * @since 1.0.0
 */
export declare const struct: <R extends Record<string, Validated<any, any>>>(r: R) => Validated<[
    R[keyof R]
] extends [Validated<infer E, any>] ? E : never, {
    [K in keyof R]: [R[K]] extends [Validated<any, infer A>] ? A : never;
}>;
/**
 * @category sequencing
 * @since 1.0.0
 */
export declare const flatMap: {
    <A, E2, B>(f: (a: A) => Validated<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, B>;
    <E1, A, E2, B>(self: Validated<E1, A>, f: (a: A) => Validated<E2, B>): Validated<E1 | E2, B>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Applicative: applicative.Applicative<ValidatedTypeLambda>;
/**
 * @category combining
 * @since 1.0.0
 */
export declare const getFirstLeftMonoid: <A, E>(M: Monoid<A>) => Monoid<Validated<E, A>>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const FlatMap: flatMap_.FlatMap<ValidatedTypeLambda>;
/**
 * @since 1.0.0
 */
export declare const flatten: <E2, E1, A>(self: Validated<E2, Validated<E1, A>>) => Validated<E2 | E1, A>;
/**
 * @since 1.0.0
 */
export declare const andThen: {
    <E1, _, E2, B>(self: Validated<E1, _>, that: Validated<E2, B>): Validated<E1 | E2, B>;
    <E2, B>(that: Validated<E2, B>): <E1, _>(self: Validated<E1, _>) => Validated<E2 | E1, B>;
};
/**
 * @since 1.0.0
 */
export declare const composeKleisliArrow: {
    <A, E1, B, E2, C>(afb: (a: A) => Validated<E1, B>, bfc: (b: B) => Validated<E2, C>): (a: A) => Validated<E1 | E2, C>;
    <B, E2, C>(bfc: (b: B) => Validated<E2, C>): <A, E1>(afb: (a: A) => Validated<E1, B>) => (a: A) => Validated<E2 | E1, C>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Chainable: chainable.Chainable<ValidatedTypeLambda>;
/**
 * Sequences the specified effect after this effect, but ignores the value
 * produced by the effect.
 *
 * @category sequencing
 * @since 1.0.0
 */
export declare const andThenDiscard: {
    <E1, A, E2, _>(self: Validated<E1, A>, that: Validated<E2, _>): Validated<E1 | E2, A>;
    <E2, _>(that: Validated<E2, _>): <E1, A>(self: Validated<E1, A>) => Validated<E2 | E1, A>;
};
/**
 * Returns an effect that effectfully "peeks" at the success of this effect.
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const tap: {
    <E1, A, E2, _>(self: Validated<E1, A>, f: (a: A) => Validated<E2, _>): Validated<E1 | E2, A>;
    <A, E2, _>(f: (a: A) => Validated<E2, _>): <E1>(self: Validated<E1, A>) => Validated<E2 | E1, A>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Monad: monad.Monad<ValidatedTypeLambda>;
/**
 * @category algebraic operations
 * @since 1.0.0
 */
export declare const sum: {
    <E1, E2>(self: Validated<E1, number>, that: Validated<E2, number>): Validated<E1 | E2, number>;
    <E2>(that: Validated<E2, number>): <E1>(self: Validated<E1, number>) => Validated<E2 | E1, number>;
};
/**
 * @category algebraic operations
 * @since 1.0.0
 */
export declare const multiply: {
    <E1, E2>(self: Validated<E1, number>, that: Validated<E2, number>): Validated<E1 | E2, number>;
    <E2>(that: Validated<E2, number>): <E1>(self: Validated<E1, number>) => Validated<E2 | E1, number>;
};
/**
 * @category algebraic operations
 * @since 1.0.0
 */
export declare const subtract: {
    <E1, E2>(self: Validated<E1, number>, that: Validated<E2, number>): Validated<E1 | E2, number>;
    <E2>(that: Validated<E2, number>): <E1>(self: Validated<E1, number>) => Validated<E2 | E1, number>;
};
/**
 * @category algebraic operations
 * @since 1.0.0
 */
export declare const divide: {
    <E1, E2>(self: Validated<E1, number>, that: Validated<E2, number>): Validated<E1 | E2, number>;
    <E2>(that: Validated<E2, number>): <E1>(self: Validated<E1, number>) => Validated<E2 | E1, number>;
};
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const bindTo: {
    <N extends string>(name: N): <E, A>(self: These<E, A>) => These<E, {
        [K in N]: A;
    }>;
    <E, A, N extends string>(self: These<E, A>, name: N): These<E, {
        [K in N]: A;
    }>;
};
declare const let_: {
    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): <E>(self: These<E, A>) => These<E, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
    <E, A extends object, N extends string, B>(self: These<E, A>, name: Exclude<N, keyof A>, f: (a: A) => B): These<E, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
};
export { 
/**
 * @category do notation
 * @since 1.0.0
 */
let_ as let };
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const Do: These<never, {}>;
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const bind: {
    <N extends string, A extends object, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => Validated<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E2 | E1, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
    <E1, A extends object, N extends string, E2, B>(self: Validated<E1, A>, name: Exclude<N, keyof A>, f: (a: A) => Validated<E2, B>): Validated<E1 | E2, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
};
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const bindEither: {
    <N extends string, A extends object, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => Either<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, {
        [K in keyof A | N]: K extends keyof A ? A[K] : B;
    }>;
    <E1, A extends object, N extends string, E2, B>(self: Validated<E1, A>, name: Exclude<N, keyof A>, f: (a: A) => Either<E2, B>): Validated<E1 | E2, {
        [K in keyof A | N]: K extends keyof A ? A[K] : B;
    }>;
};
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const bindThese: {
    <N extends string, A extends object, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => These<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E1 | E2, {
        [K in keyof A | N]: K extends keyof A ? A[K] : B;
    }>;
    <E1, A extends object, N extends string, E2, B>(self: Validated<E1, A>, name: Exclude<N, keyof A>, f: (a: A) => These<E2, B>): Validated<E1 | E2, {
        [K in keyof A | N]: K extends keyof A ? A[K] : B;
    }>;
};
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const andThenBind: {
    <N extends string, A extends object, E2, B>(name: Exclude<N, keyof A>, that: Validated<E2, B>): <E1>(self: Validated<E1, A>) => Validated<E2 | E1, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
    <E1, A extends object, N extends string, E2, B>(self: Validated<E1, A>, name: Exclude<N, keyof A>, that: Validated<E2, B>): Validated<E1 | E2, {
        [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
};
//# sourceMappingURL=These.d.ts.map