import type { Kind, InvariantParam, CovariantParam } from '../../kinds/index.js';
import * as tFunctor from '../../typeclass/functor';
import * as tbifunctor from '../../typeclass/bifunctor';
import * as tOf from '../../typeclass/of';
import * as tTo from '../../typeclass/to';
import * as tFlip from '../../typeclass/flip';
import * as tApplicative from '../../typeclass/applicative';
import * as tMonad from '../../typeclass/monad';
import * as tBiFlatMap from '../../typeclass/biflatmap';
import * as tFoldable from '../../typeclass/foldable';
import * as tTraversable from '../../typeclass/traversable';
import * as tSemiAlternative from '../../typeclass/semialternative';
import * as tSemiAlign from '../../typeclass/semialign';
import * as O from '../option';
import { Result, Err, Ok } from './result.types';
export declare const err: <E, A = never>(e: E) => Result<A, E>;
export declare const ok: <A, E = never>(a: A) => Result<A, E>;
export declare const isErr: <A, E>(result: Result<A, E>) => result is Err<A, E>;
export declare const isOk: <A, E>(result: Result<A, E>) => result is Ok<A, E>;
export interface TResult extends Kind<[InvariantParam, CovariantParam]> {
    return: Result<this['arg0'], this['arg1']>;
}
export declare const Of: tOf.Of<TResult>;
export declare const To: tTo.To<TResult>;
export declare const OptionalTo: tTo.OptionalTo<TResult>;
export declare const Flip: tFlip.Flip<TResult>;
export declare const Bifunctor: tbifunctor.BiFunctor<TResult>;
export declare const BiFlatMap: tBiFlatMap.BiFlatMap<TResult>;
export declare const Functor: tFunctor.Functor<TResult>;
export declare const SemiAlternative: tSemiAlternative.SemiAlternative<TResult>;
export declare const Foldable: tFoldable.Foldable<TResult>;
export declare const Applicative: tApplicative.Applicative<TResult>;
export declare const Monad: tMonad.Monad<TResult>;
export declare const Traversable: tTraversable.Traversable<TResult>;
export declare const SemiAlign: tSemiAlign.SemiAlign<TResult>;
export declare const match: <A, B, C, E>(onOk: (a: A) => B, onErr: (e: E) => C) => (result: Result<A, E>) => B | C;
/**
 * of :: `a -> Result<a, never>`
 *
 * of :: `<A>(a: A) => Result<A, never>`
 *
 * @param a any value
 * @returns `Result<a, never>`
 *
 * @example
 * ```ts
 * pipe(1, of) // ok(1)
 * ```
 */
export declare const of: <A>(a: A) => Result<A, never>;
/**
 * getOrElse :: `(e -> b) -> Result<a, e> -> a | b`
 *
 * getOrElse :: `<A, B>(f: (e: E) => B) => (fa: Result<A, E>) => A | B`
 *
 * @param f `e -> b`
 * @returns `Result<a, e> -> a | b`
 *
 * @example
 * ```ts
 * pipe(ok(0), getOrElse(() => 1)) // 0
 * pipe(err("error"), getOrElse(() => 1)) // 1
 * ```
 */
export declare const getOrElse: <A1, A2>(f: (args_0: A2) => A1) => <A>(fa: Result<A, A2>) => A1 | A;
/**
 * getOr :: `b -> Result<a, e> -> a | b`
 *
 * getOr :: `<B>(b: B) => <A,E>(fa: Result<A, E>) => A | B`
 *
 * @param b `b`
 * @returns `Result<a, e> -> a | b`
 *
 * @example
 * ```ts
 * pipe(ok(0), getOr(1)) // 0
 * pipe(err("error"), getOr(1)) // 1
 * ```
 */
export declare const getOr: <A1>(args_0: A1) => <B1, B2>(args_0: Result<B1, B2>) => A1 | B1;
/**
 * flip :: `Result<a, e> -> Result<e, a>`
 *
 * @param fa `Result<a, e>`
 * @returns `Result<e, a>`
 *
 * @example
 * ```ts
 * pipe(ok(0), flip) // err(0)
 * pipe(err("error"), flip) // ok("error")
 * ```
 */
export declare const flip: <A1, A2>(args_0: Result<A1, A2>) => Result<A2, A1>;
/**
 * get :: `Result<a, e> -> Option<a>`
 *
 * get :: `<A, E>(fa: Result<A, E>) => Option<A>`
 *
 * @param fa `Result<a, e>`
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(ok(0), get) // some(0)
 * pipe(err("error"), get) // none
 * ```
 */
export declare const get: <A1, A2>(args_0: Result<A1, A2>) => O.Option<A1>;
/**
 * alias of {@link get}
 *
 * toOption :: `Result<a, e> -> Option<a>`
 *
 * toOption :: `<A, E>(fa: Result<A, E>) => Option<A>`
 *
 * @param fa `Result<a, e>`
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(ok(0), toOption) // some(0)
 * pipe(err("error"), toOption) // none
 * ```
 */
export declare const toOption: <A1, A2>(args_0: Result<A1, A2>) => O.Option<A1>;
/**
 * fromOption :: `(() -> e ) -> Option<a> -> Result<a, e>`
 *
 * fromOption :: `<A, E>(onErr: () => E) => (option: O.Option<A>): Result<A, E>`
 *
 * @param onErr A function that returns an error of type `E`.
 * @returns A function that takes an `Option<A>` and returns a `Result<A, E>`.
 *
 * @example
 * ```ts
 * pipe(some(0), fromOption(() => "error")) // ok(0)
 * pipe(none(), fromOption(() => "error")) // err("error")
 * ```
 */
export declare const fromOption: <A, E>(onErr: () => E) => (option: O.Option<A>) => Result<A, E>;
/**
 * fromNullable :: `(() -> e) -> a | null | undefined -> Result<a, e>`
 *
 * fromNullable :: `<A, E>(onErr: () => E) => (a: A | null | undefined) => Result<A, E>`
 *
 * @param onErr A function that returns an error of type `E`.
 * @returns A function that takes a value of type `A | null | undefined` and returns a `Result<A, E>`.
 *
 * @example
 * ```ts
 * pipe(0, fromNullable(() => "error")) // ok(0)
 * pipe(null, fromNullable(() => "error")) // err("error")
 * pipe(undefined, fromNullable(() => "error")) // err("error")
 * ```
 */
export declare const fromNullable: <A, E>(onErr: () => E) => (a: A | null | undefined) => Result<A, E>;
/**
 * fromPredicate :: `(a -> boolean) (a -> e) -> a -> Result<a, e>`
 *
 * fromPredicate :: `<A, E>(predicate: (a: A) => boolean, onErr: (a: A) => E) => (a: A) => Result<A, E>`
 *
 * @param predicate A function that takes a value of type `A` and returns a boolean.
 * @param onErr A function that takes a value of type `A` and returns an error of type `E`.
 * @returns A function that takes a value of type `A` and returns a `Result<A, E>`.
 *
 * @example
 * ```ts
 * pipe(0, fromPredicate(x => x === 0, () => "error")) // ok(0)
 * pipe(1, fromPredicate(x => x === 0, () => "error")) // err("error")
 * ```
 */
export declare const fromPredicate: <A, E>(predicate: (a: A) => boolean, onErr: (a: A) => E) => (a: A) => Result<A, E>;
/**
 * orElse :: `(e1 -> Result<a, e2>) -> Result<a, e1> -> Result<a, e2>`
 *
 * orElse :: `<A, E1, E2>(f: (e: E1) => Result<A, E2>) => (fa: Result<A, E1>) => Result<A, E2>`
 *
 * @param f `e1 -> Result<a, e2>`
 * @returns `Result<a, e1> -> Result<a, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(0), orElse(() => ok(1))) // ok(0)
 * pipe(err("error"), orElse(() => ok(1))) // ok(1)
 * pipe(err("error"), orElse((e) => err(`${e}!`))) // err("error!")
 * ```
 */
export declare const orElse: <A1, A2, A3>(args_0: (args_0: A1) => Result<A2, A3>) => (args_0: Result<A2, A1>) => Result<A2, A3>;
/**
 * less strict version of {@link orElse}
 *
 * orElseW :: `(e1 -> Result<a2, e2>) -> Result<a1, e1> -> Result<a1 | a2, e2>`
 *
 * @param f `(e1 -> Result<a2, e2>)`
 * @returns `Result<a1, e1> -> Result<a1 | a2, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(0), orElseW(() => ok(1))) // ok(0)
 * pipe(ok(0), orElseW(() => ok("hello"))) // ok(0)
 * pipe(err("error"), orElseW(() => ok(1))) // ok(1)
 * pipe(err("error"), orElseW(() => err("error!"))) // err("error!")
 * ```
 */
export declare const orElseW: <E1, E2, A2>(f: (e: E1) => Result<A2, E2>) => <A1>(fa: Result<A1, E1>) => Result<A1 | A2, E2>;
/**
 * Alternative version of orElse
 *
 * orElseAlt :: `(() -> Result<a, e1>) -> Result<a, e2> -> Result<a, e1>`
 *
 * orElseAlt :: `<A, E1>(fb: () => Result<A, E1>) => <E2>(fa: Result<A, E2>) => Result<A, E1>`
 *
 * @param fb `() -> Result<a, e1>`
 * @returns `Result<a, e2> -> Result<a, e1>`
 *
 * @example
 * ```ts
 * pipe(ok(0), orElseAlt(() => ok(1))) // ok(0)
 * pipe(err("error"), orElseAlt(() => ok(1))) // ok(1)
 * pipe(err("error"), orElseAlt(() => err("error!"))) // err("error!")
 * ```
 */
export declare const orElseAlt: <A1, A2>(args_0: () => Result<A1, A2>) => <B1>(args_0: Result<A1, B1>) => Result<A1, A2>;
/**
 *  or :: `Result<a, e1> -> Result<a, e2> -> Result<a, e1>`
 *
 * or :: `<A, E1>(fb: Result<A, E1>) => <E2>(fa: Result<A, E2>) => Result<A, E1>`
 *
 * @param fb `Result<a, e1>`
 * @returns `Result<a, e2> -> Result<a, e1>`
 *
 * @example
 * ```ts
 * pipe(ok(0), or(ok(1))) // ok(0)
 * pipe(err("error"), or(ok(1))) // ok(1)
 * pipe(err("error"), or(err("error!"))) // err("error!")
 * ```
 */
export declare const or: <A1, A2>(args_0: Result<A1, A2>) => <B1>(args_0: Result<A1, B1>) => Result<A1, A2 | B1>;
/**
 * map :: `(a -> b) -> Result<a, e> -> Result<b, e>`
 *
 * map :: `<A, B>(f: (a: A) => B) => <E>(fa: Result<A, E>) => Result<B, E>`
 *
 * @param f `a -> b`
 * @returns `Result<a, e> -> Result<b, e>`
 *
 * @example
 * ```ts
 * pipe(ok(0), map(x => x + 1)) // ok(1)
 * pipe(err("error"), map(x => x + 1)) // err("error")
 * ```
 */
export declare const map: <A1, A2>(args_0: (args_0: A1) => A2) => <B1>(args_0: Result<A1, B1>) => Result<A2, B1>;
/**
 * reduce :: `(b a -> b) b -> Result<a, e> -> b`
 *
 * reduce :: `<A, B>(f: (b: B, a: A) => B, b: B) => <E>(fa: Result<A, E>) => B`
 *
 * @param f `(b a -> b) b`
 * @param b `b`
 * @returns `Result<a, e> -> b`
 *
 * @example
 * ```ts
 * pipe(ok(0), reduce((b, a) => b + a, 0)) // 0
 * pipe(err("error"), reduce((b, a) => b + a, 0)) // 0
 * ```
 */
export declare const reduce: <A1, A2>(args_0: (args_0: A1, args_1: A2) => A1, args_1: A1) => <B1>(args_0: Result<A2, B1>) => A1;
/**
 * flap :: `a -> Result<(a -> b), e> -> Result<b, e>`
 *
 * flap :: `<A>(a: A) => <B, E>(fab: Result<(a: A) => B, E>) => Result<B, E>`
 *
 * @param a `a`
 * @returns `Result<(a -> b), e> -> Result<b, e>`
 *
 * @example
 * ```ts
 * pipe(ok(x => x + 1), flap(0)) // ok(1)
 * pipe(err("error"), flap(0)) // err("error")
 * ```
 */
export declare const flap: <A1>(args_0: A1) => <B1, B2>(args_0: Result<(args_0: A1) => B1, B2>) => Result<B1, B2>;
/**
 * as :: `b -> Result<a, e> -> Result<b, e>`
 *
 * as :: `<B>(b: B) => <A,E>(fa: Result<A, E>) => Result<B, E>`
 *
 * @param b `b`
 * @returns `Result<a, e> -> Result<b, e>`
 *
 * @example
 * ```ts
 * pipe(ok(0), as(1)) // ok(1)
 * pipe(err("error"), as(1)) // err("error")
 * ```
 */
export declare const as: <A1>(args_0: A1) => <B1, B2>(args_0: Result<B1, B2>) => Result<A1, B2>;
/**
 * tap :: `(a -> void) -> Result<a, e> -> Result<a, e>`
 *
 * tap :: `<A>(f: (a: A) => void) => <E>(fa: Result<A, E>) => Result<A, E>`
 *
 * @param f `(a -> void)`
 * @returns `Result<a, e> -> Result<a, e>`
 *
 * @example
 * ```ts
 * pipe(ok(0), tap(x => console.log(x))) // ok(0)
 * pipe(err("error"), tap(x => console.log(x))) // err("error")
 * ```
 */
export declare const tap: <A1>(args_0: (args_0: A1) => void) => <B1>(args_0: Result<A1, B1>) => Result<A1, B1>;
/**
 * doubleMap :: `(a -> b) -> Result<Result<a, e1>, e2> -> Result<Result<b, e1>, e2>`
 *
 * doubleMap :: `<A, B>(f: (a: A) => B) => <E1, E2>(fa: Result<Result<A, E1>, E2>) => Result<Result<B, E1>, E2>`
 *
 * @param f `a -> b`
 * @returns `Result<Result<a, e1>, e2> -> Result<Result<b, e1>, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(ok(0)), doubleMap(x => x + 1)) // ok(ok(1))
 * pipe(err("error"), doubleMap(x => x + 1)) // err("error")
 * ```
 */
export declare const doubleMap: <A1, A2>(args_0: (args_0: A1) => A2) => <B1, B2>(args_0: Result<Result<A1, B1>, B2>) => Result<Result<A2, B1>, B2>;
/**
 * bimap :: `(a -> b) (e1 -> e2) -> Result<a, e1> -> Result<b, e2>`
 *
 * bimap :: `<A, B, E1, E2>(f: (a: A) => B, g: (e: E1) => E2) => (fa: Result<A, E1>) => Result<B, E2>`
 *
 * @param f `a -> b`
 * @param g `e1 -> e2`
 * @returns `Result<a, e1> -> Result<b, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(0), bimap(x => x + 1, x => x + "!")) // ok(1)
 * pipe(err("error"), bimap(x => x + 1, x => x + "!")) // err("error!")
 * ```
 */
export declare const bimap: <A1, A2, A3, A4>(args_0: (args_0: A1) => A2, args_1: (args_0: A3) => A4) => (args_0: Result<A1, A3>) => Result<A2, A4>;
export declare const bitap: <A1, A2>(args_0: (args_0: A1) => void, args_1: (args_0: A2) => void) => (args_0: Result<A1, A2>) => Result<A1, A2>;
export declare const mapLeft: <A1, A2>(args_0: (args_0: A1) => A2) => <B1>(args_0: Result<A1, B1>) => Result<A2, B1>;
export declare const mapRight: <A1, A2>(args_0: (args_0: A1) => A2) => <B1>(args_0: Result<B1, A1>) => Result<B1, A2>;
export declare const tapLeft: <A1>(args_0: (args_0: A1) => void) => <B1>(args_0: Result<A1, B1>) => Result<A1, B1>;
export declare const tapRight: <A1>(args_0: (args_0: A1) => void) => <B1>(args_0: Result<B1, A1>) => Result<B1, A1>;
export declare const tapErr: <A1>(args_0: (args_0: A1) => void) => <B1>(args_0: Result<B1, A1>) => Result<B1, A1>;
/**
 * mapErr :: `(e1 -> e2) -> Result<a, e1> -> Result<a, e2>`
 *
 * mapErr :: `<E1, E2>(f: (e: E1) => E2) => <A>(fa: Result<A, E1>) => Result<A, E2>`
 *
 * @param f `e1 -> e2`
 * @returns `Result<a, e1> -> Result<a, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(0), mapErr(x => x + "!")) // ok(0)
 * pipe(err("error"), mapErr(x => x + "!")) // err("error!")
 */
export declare const mapErr: <A1, A2>(args_0: (args_0: A1) => A2) => <B1>(args_0: Result<B1, A1>) => Result<B1, A2>;
/**
 * ap :: `Result<a, e1> -> Result<(a -> b), e2> -> Result<b, e1 | e2>`
 *
 * ap :: `<A, E1>(fa: Result<A, E1>) => <B, E2>(fab: Result<(a: A) => B, E2>) => Result<B, E1 | E2>`
 *
 * @param fa `Result<a, e1>`
 * @returns fab: `Result<(a -> b), e2> -> Result<b, e1 | e2>`
 *
 * @example
 * ```ts
 * pipe(of(x => x + 1), ap(ok(0))) // ok(1)
 * pipe(err("error"), ap(ok(0))) // err("error")
 * pipe(of(x => x + 1), ap(err("error"))) // err("error")
 * ```
 */
export declare const ap: <A1, A2>(args_0: Result<A1, A2>) => <B1, B2>(args_0: Result<(args_0: A1) => B1, B2>) => Result<B1, A2 | B2>;
export declare const liftA2: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => <B1>(args_0: Result<A1, B1>) => <C1>(args_0: Result<A2, C1>) => Result<A3, B1 | C1>;
export declare const product: <A1, A2>(args_0: Result<A1, A2>) => <B1, B2>(args_0: Result<B1, B2>) => Result<[A1, B1], A2 | B2>;
export declare const productMany: <A1, A2>(args_0: Result<A1, A2>) => (args_0: Result<A1, A2>[]) => Result<A1[], A2>;
/**
 * flatMap :: `(a -> Result<b, e1>) -> Result<a, e2> -> Result<b, e1 | e2>`
 *
 * flatMap :: `<A, B, E1>(f: (a: A) => Result<B, E1>) => <E2>(fa: Result<A, E2>) => Result<B, E1 | E2>`
 *
 * @param f `a -> Result<b, e1>`
 * @returns `Result<a, e2> -> Result<b, e1 | e2>`
 *
 * @example
 * ```ts
 * pipe(ok(5), flatMap(x => ok(x + 1))) // ok(6)
 * pipe(err("error"), flatMap(x => ok(x + 1))) // err("error")
 * pipe(ok(5), flatMap(x => err("error"))) // err("error")
 * ```
 */
export declare const flatMap: <A1, A2, A3>(args_0: (args_0: A1) => Result<A2, A3>) => <B1>(args_0: Result<A1, B1>) => Result<A2, A3 | B1>;
/**
 * alias for {@link flatMap}
 */
export declare const andThen: <A1, A2, A3>(args_0: (args_0: A1) => Result<A2, A3>) => <B1>(args_0: Result<A1, B1>) => Result<A2, A3 | B1>;
/**
 * alias of {@link flatMap}
 */
export declare const chain: <A1, A2, A3>(args_0: (args_0: A1) => Result<A2, A3>) => <B1>(args_0: Result<A1, B1>) => Result<A2, A3 | B1>;
/**
 * flatten :: `Result<Result<a, e1>, e2> -> Result<a, e1 | e2>`
 *
 * flatten :: `<A, E1, E2>(ffa: Result<Result<A, E1>, E2>) => Result<A, E1 | E2>`
 *
 * @param ffa `Result<Result<a, e1>, e2>`
 * @returns `Result<a, e1 | e2>`
 *
 * @example
 * ```ts
 * pipe(ok(ok(0)), flatten) // ok(0)
 * pipe(ok(err("error")), flatten) // err("error")
 * pipe(err("error"), flatten) // err("error")
 * ```
 */
export declare const flatten: <A1, A2, A3>(args_0: Result<Result<A1, A2>, A3>) => Result<A1, A2 | A3>;
/**
 * biFlapMap :: `(a -> Result<b, e2>) (e1 -> Result<b, e2>) -> Result<a, e1> -> Result<b, e2>`
 *
 * biFlapMap :: `<A, B, E1, E2>(f: (a: A) => Result<B, E2>, g: (e: E1) => Result<B, E2>) => (fa: Result<A, E1>) => Result<B, E2>`
 *
 * @param f `a -> Result<b, e2>`
 * @param g `e1 -> Result<b, e2>`
 * @returns `Result<a, e1> -> Result<b, e2>`
 *
 * @example
 * ```ts
 * pipe(ok(0), biFlapMap(x => ok(x + 1), x => err("error"))) // ok(1)
 * pipe(err("error"), biFlapMap(x => ok(x + 1), x => err("error!"))) // err("error!")
 * ```
 */
export declare const biFlatMap: <A1, A2, A3, A4>(args_0: (args_0: A1) => Result<A2, A3>, args_1: (args_0: A4) => Result<A2, A3>) => (args_0: Result<A1, A4>) => Result<A2, A3>;
/**
 * traverse :: `Applicative f => (a -> f b) -> Result<a, e> -> f Result<b, e>`
 *
 * traverse :: `<F extends Kind>(applicative: Applicative<F>) => <A, B>(f: (a: A) => $<F, [B]>) => <E>(fa: Result<A, E>) => $<F, [Result<B, E>]>
 *
 * @param applicative `Applicative<F>`
 * @returns `(a -> f b) -> Result<a, e> -> f Result<b, e>`
 *
 * @example
 * ```ts
 * const traverseOption = traverse(O.Applicative);
 * pipe(ok(0), traverseOption(x => some(x + 1))) // some(ok(1))
 * pipe(err("error"), traverseOption(x => some(x + 1))) // some(err("error"))
 * pipe(ok(0), traverseOption(x => none)) // none
 * ```
 */
export declare const traverse: <F extends Kind>(F: tApplicative.Applicative<F>) => tTraversable.Traversable.$traverse<TResult, F>;
/**
 * sequence :: `Applicative f => Result<f a, e> -> f Result<a, e>`
 *
 * sequence :: `<F extends Kind>(applicative: Applicative<F>) => <A, E>(fa: Result<$<F, [A]>, E>) => $<F, [Result<A, E>]>
 *
 * @param applicative `Applicative<F>`
 * @returns `Result<f a, e> -> f Result<a, e>`
 *
 * @example
 * ```ts
 * const sequenceOption = sequence(O.Applicative);
 * pipe(ok(some(0)), sequenceOption) // some(ok(0))
 * pipe(ok(none), sequenceOption) // none
 * pipe(err("error"), sequenceOption) // some(err("error"))
 * ```
 */
export declare const sequence: <F extends Kind>(F: tApplicative.Applicative<F>) => tTraversable.Traversable.$sequence<TResult, F>;
export declare const pluck: <A, K extends keyof A>(k: K) => <B1>(args_0: Result<A, B1>) => Result<A[K], B1>;
export declare const zipWith: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => <B1>(args_0: Result<A1, B1>) => <C1>(args_0: Result<A2, C1>) => Result<A3, B1 | C1>;
export declare const zip: <A1, A2>(args_0: Result<A1, A2>) => <B1, B2>(args_0: Result<B1, B2>) => Result<[A1, B1], A2 | B2>;