interface OkResult<T> {
    readonly value: T;
    readonly isOk: true;
    readonly isErr: false;
    readonly isError: false;
    map<S>(fn: (data: T) => S): OkResult<S>;
    mapErr(fn: (error: never) => unknown): OkResult<T>;
    chain<S, F>(next: (data: T) => Result$1<S, F>): Result$1<S, F>;
    chainErr(next: (error: never) => Result$1<unknown, unknown>): OkResult<T>;
    unwrap(): T;
    unwrapOr(fallback: unknown): T;
    unwrapOrElse(fallback: (error: never) => unknown): T;
    unwrapErr(): never;
    unwrapErrOr<F>(fallback: F): F;
    unwrapErrOrElse<F>(fallback: (value: T) => F): F;
    unwrapOrThrow(): T;
    unpack(): T;
    match<TR, ER>(okMatcher: (data: T) => TR, errMatcher: (error: never) => ER): TR;
    tap(fn: (data: T) => void): OkResult<T>;
    tapErr(fn: unknown): OkResult<T>;
    biMap<S, F>(okFn: (data: T) => S, errFn: (error: never) => F): OkResult<S>;
    biChain<TS, TF, ES, EF>(okFn: (data: T) => Result$1<TS, TF>, errFn: (error: never) => Result$1<ES, EF>): Result$1<TS, TF>;
    asTuple(): [ok: true, error: undefined, value: T];
    [Symbol.iterator](): Generator<never, T>;
}
interface ErrResult<E> {
    readonly error: E;
    readonly isOk: false;
    readonly isErr: true;
    readonly isError: true;
    map(fn: (data: never) => unknown): ErrResult<E>;
    mapErr<F>(fn: (error: E) => F): ErrResult<F>;
    chain(next: (value: never) => Result$1<unknown, unknown>): ErrResult<E>;
    chainErr<S, F>(next: (error: E) => Result$1<S, F>): Result$1<S, F>;
    unwrap(): never;
    unwrapOr<S>(fallback: S): S;
    unwrapOrElse<S>(fallback: (error: E) => S): S;
    unwrapErr(): E;
    unwrapErrOr<F>(fallback: F): E;
    unwrapErrOrElse(fallback: (value: never) => unknown): E;
    unwrapOrThrow(): never;
    unpack(): E;
    match<TR, ER>(okMatcher: (value: never) => TR, errMatcher: (error: E) => ER): ER;
    tap(fn: (value: never) => unknown): ErrResult<E>;
    tapErr(fn: (error: E) => void): ErrResult<E>;
    biMap<S, F>(okFn: (value: never) => S, errFn: (error: E) => F): ErrResult<F>;
    biChain<TS, TF, ES, EF>(okFn: (value: never) => Result$1<TS, TF>, errFn: (error: E) => Result$1<ES, EF>): Result$1<ES, EF>;
    asTuple(): [ok: false, error: E, value: undefined];
    [Symbol.iterator](): Generator<E, never>;
}
type Result$1<T, E> = OkResult<T> | ErrResult<E>;
type NotResultOf<T> = T extends Result$1<any, any> ? never : T;
type ErrTypeOf<T> = T extends ErrResult<infer E> ? E : never;
type OkTypeOf<T> = T extends OkResult<infer R> ? R : never;
type AsyncResult<T, E> = Promise<Result$1<T, E>>;
type AsyncOk<T> = AsyncResult<T, never>;
type AsyncErr<E> = AsyncResult<never, E>;
type MaybeAsync<T> = T | Promise<T>;
type MaybeAsyncResult<T, E> = Result$1<T, E> | AsyncResult<T, E>;
type Collected<R extends readonly unknown[] | []> = {
    -readonly [K in keyof R]: OkTypeOf<R[K]>;
};
type CollectedErr<R extends readonly unknown[] | []> = {
    -readonly [K in keyof R]: ErrTypeOf<R[K]>;
};
type AsyncCollected<T extends readonly unknown[] | []> = {
    -readonly [K in keyof T]: OkTypeOf<Awaited<T[K]>>;
};
type ResultOf<T extends (...args: any[]) => Result$1<any, any>> = Result$1<OkTypeOf<ReturnType<T>>, ErrTypeOf<ReturnType<T>>>;

type OkType<T> = OkResult<T>;
declare const ok: <T>(value: T) => OkType<T>;
declare const asyncOk: <T>(value: T | Promise<T>) => AsyncOk<T>;

type ErrType<E> = ErrResult<E>;
declare const err: <E>(error: E) => ErrType<E>;
declare const asyncErr: <E>(error: E | Promise<E>) => AsyncErr<E>;

declare function rTry<Args extends unknown[]>(fn: (...args: Args) => never, ...args: Args): ErrResult<unknown>;
declare function rTry<T, Args extends unknown[]>(fn: () => Promise<T>, ...args: Args): Promise<Result$1<T, unknown>>;
declare function rTry<T, Args extends unknown[]>(fn: (...args: Args) => T, ...args: Args): Result$1<T, unknown>;
declare function rTry<T>(promise: Promise<T>): Promise<Result$1<T, unknown>>;
declare function rTry<T>(value: T): Result$1<T, unknown>;

declare const isResult: (value: unknown) => value is Result$1<unknown, unknown>;
declare const isOk: <T>(value: Result$1<T, unknown>) => value is OkResult<T>;
declare const isError: <E>(value: Result$1<unknown, E>) => value is ErrResult<E>;
declare const isErr: <E>(value: Result$1<unknown, E>) => value is ErrResult<E>;
declare const ensureResult: <T, S, E>(value: T | Result$1<S, E>) => Result$1<T | S, E>;

declare const okIf: {
    <T, S extends T, F>(value: T, guard: (data: T) => data is S, fallback: F | ((value: Exclude<T, S>) => F)): Result$1<S, F>;
    <T, F>(value: T, predicate: (data: T) => boolean, fallback: F | ((value: T) => F)): Result$1<T, F>;
};
declare const expect: {
    <T, S extends T, F>(guard: (data: T) => data is S, fallback: F | ((value: Exclude<T, S>) => F)): (value: T) => Result$1<S, F>;
    <T, F>(predicate: (data: T) => boolean, fallback: F | ((value: T) => F)): (value: T) => Result$1<T, F>;
};
declare const expectExists: <E>(fallback: E | ((value: undefined | null) => E)) => <T>(value: T | undefined | null) => Result$1<T, E>;
declare const okIfExists: <T, E>(value: T | undefined | null, fallback: E | ((value: undefined | null) => E)) => Result$1<T, E>;

type Job<T, E> = () => Generator<E, T>;
type Method<T, E, This> = {
    (this: This): Generator<E, T>;
};
type AsyncJob<T, E> = () => AsyncGenerator<E, T>;
type AsyncMethod<T, E, This> = {
    (this: This): AsyncGenerator<E, T>;
};
declare function Do<T, E>(job: AsyncJob<T, E>): Promise<Result$1<OkTypeOf<T> | NotResultOf<T>, E | ErrTypeOf<T>>>;
declare function Do<T, E, This>(method: AsyncMethod<T, E, This>, thisArg: This): Promise<Result$1<OkTypeOf<T> | NotResultOf<T>, E | ErrTypeOf<T>>>;
declare function Do<T, E>(job: Job<T, E>): Result$1<OkTypeOf<T> | NotResultOf<T>, E | ErrTypeOf<T>>;
declare function Do<T, E, This>(method: Method<T, E, This>, thisArg: This): Result$1<OkTypeOf<T> | NotResultOf<T>, E | ErrTypeOf<T>>;

/**
 * Reduces an array of `Result` objects into a single `Result` by applying a reducer function.
 *
 * @param results - An array of `Result` objects.
 * @param reducer - A function that takes an accumulator, a result, an index, and the list of results, and returns the updated accumulator.
 * @param initial - The initial value of the accumulator.
 * @returns A `Result` object that represents the reduced value.
 * @template T - The type of the successful result.
 * @template S - The type of the accumulator.
 * @template E - The type of the error.
 */
declare const reduce: <T, S, E>(results: readonly Result$1<T, E>[], reducer: (acc: S, result: T, index: number, list: readonly Result$1<T, E>[]) => S, initial: S) => Result$1<S, E>;
/**
 * Reduces an array of `Result` objects by applying a reducer function to each error value.
 * If any of the `Result` objects is an `Ok` variant, it is returned as is.
 * If all `Result` objects are `Err` variants, the reducer function is applied to each error value
 * in the array, starting with the initial value, and the final result is wrapped in an `Err` variant.
 *
 * @param results - An array of `Result` objects.
 * @param reducer - A function that takes an accumulator and an error value, and returns the updated accumulator.
 * @param initial - The initial value of the accumulator.
 * @returns A `Result` object that is either an `Ok` variant if any of the `Result` objects is an `Ok` variant,
 * or an `Err` variant with the final result of applying the reducer function to each error value.
 * @template T - The type of the value in the `Ok` variant of the `Result` objects.
 * @template S - The type of the accumulator.
 * @template E - The type of the value in the `Err` variant of the `Result` objects.
 */
declare const reduceErr: <T, S, E>(results: readonly Result$1<T, E>[], reducer: (acc: S, err: E) => S, initial: S) => Result$1<T, S>;
/**
 * Collects the results of an array of `Result` objects into a single `Result` object.
 *
 * @template R - The array type containing `Result` objects.
 * @param results - The array of `Result` objects to collect.
 * @returns A `Result` object containing the collected results.
 */
declare const collect: <R extends readonly Result$1<any, any>[]>(results: R) => Result$1<Collected<R>, ErrTypeOf<R[number]>>;
/**
 * Collects the error values from an array of `Result` objects.
 *
 * @template R - The array type containing `Result` objects.
 * @param results - The array of `Result` objects.
 * @returns A `Result` object containing the collected error values.
 */
declare const collectErr: <R extends readonly Result$1<any, any>[]>(results: R) => Result$1<OkTypeOf<R[number]>, CollectedErr<R>>;
/**
 * Collects the results of multiple asynchronous operations into a single result.
 *
 * @template R - The array type containing the results of the asynchronous operations.
 * @param results - An array of promises representing the asynchronous operations.
 * @returns A promise that resolves to the collected results or rejects with the error of the first failed operation.
 */
declare const collectAsync: <R extends readonly MaybeAsyncResult<any, any>[]>(results: R) => AsyncResult<AsyncCollected<R>, ErrTypeOf<Awaited<R[number]>>>;
/**
 * Partitions an array into two separate arrays based on a given predicate.
 * The first array contains elements that satisfy the predicate, while the second array contains elements that do not.
 *
 * @param list - The array to be partitioned.
 * @param predicate - The predicate function used to determine whether an element should be included in the first array.
 * @returns An array containing two arrays: the first array contains elements that satisfy the predicate, and the second array contains elements that do not.
 */
declare const partition: {
    <T>(list: T[], predicate: (x: T) => boolean): [T[], T[]];
    <T, S extends T>(list: T[], predicate: (x: T) => x is S): [S[], Exclude<T, S>[]];
};
/**
 * Separates an array of `Result` objects into two separate `Result` objects.
 * The first `Result` contains the collected successful values, while the second `Result` contains the collected error values.
 *
 * @param results An array of `Result` objects.
 * @returns A tuple containing two `Result` objects: the first one contains the collected successful values, and the second one contains the collected error values.
 */
declare const separate: <R extends readonly Result$1<any, any>[]>(results: R) => [Result$1<Collected<R>, never>, Result$1<never, CollectedErr<R>>];
/**
 * Collects a list of `Result` values into a single `Result`.
 * - If all inputs are `Ok`, returns `Ok` with the array of unwrapped values.
 * - If any inputs are `Err`, returns `Err` with the array of ALL error values.
 *
 * @param results An array of `Result` objects.
 * @returns `Ok` of collected values or `Err` of all error values.
 */
declare const collectAll: <R extends readonly Result$1<any, any>[]>(results: R) => Result$1<Collected<R>, [ErrTypeOf<R[number]>] extends [never] ? never : ErrTypeOf<R[number]>[]>;
/**
 * Executes an array of tasks that return `Result` objects and collects their successful results.
 * If any task returns an `Err` result, the function stops executing and returns that error.
 *
 * @param tasks An array of tasks that return `Result` objects.
 * @returns A `Result` object containing an array of successful results, or an error if any task fails.
 */
declare const sequence: <T extends readonly (() => Result$1<any, any>)[]>(tasks: T) => Result$1<{ -readonly [K in keyof T]: OkTypeOf<ReturnType<T[K]>>; }, ErrTypeOf<ReturnType<T[number]>>>;
/**
 * Executes an array of asynchronous tasks sequentially and returns the results as an `AsyncResult`.
 *
 * @param tasks - An array of functions that return `MaybeAsyncResult` when executed.
 * @returns An `AsyncResult` containing the results of the executed tasks.
 */
declare const sequenceAsync: <T extends readonly (() => MaybeAsyncResult<any, any>)[]>(tasks: T) => AsyncResult<{ -readonly [K in keyof T]: OkTypeOf<Awaited<ReturnType<T[K]>>>; }, ErrTypeOf<Awaited<T[number]>>>;

declare const map: <T, S>(fn: (data: T) => S) => <E>(result: Result$1<T, E>) => Result$1<S, E>;
declare const mapErr: <E, F>(fn: (error: E) => F) => <T>(result: Result$1<T, E>) => Result$1<T, F>;
declare const chain: <T, F, S>(next: (data: T) => Result$1<S, F>) => <E>(result: Result$1<T, E>) => Result$1<S, F | E>;
declare const chainErr: <E, F, S>(next: (error: E) => Result$1<S, F>) => <T>(result: Result$1<T, E>) => Result$1<T | S, F>;
declare const unwrap: <E, T>(result: Result$1<T, E>) => T;
declare const unwrapOr: <S>(fallback: S) => <E, T>(result: Result$1<T, E>) => T | S;
declare const unwrapOrThrow: <E, T>(result: Result$1<T, E>) => T;
declare const unwrapOrElse: <E, S>(fallback: (error: E) => S) => <T>(result: Result$1<T, E>) => T | S;
declare const unwrapErr: <E, T>(result: Result$1<T, E>) => E;
declare const unwrapErrOr: <F>(fallback: F) => <E, T>(result: Result$1<T, E>) => E | F;
declare const unwrapErrOrElse: <T, F>(fallback: (data: T) => F) => <E>(result: Result$1<T, E>) => E | F;
declare const unpack: <E, T>(result: Result$1<T, E>) => E | T;
declare const match: <E, T, ER, TR>(okMatcher: (data: T) => TR, errMatcher: (error: E) => ER) => (result: Result$1<T, E>) => ER | TR;
declare const tap: <T>(fn: (data: T) => void) => <E>(result: Result$1<T, E>) => Result$1<T, E>;
declare const tapErr: <E>(fn: (error: E) => void) => <T>(result: Result$1<T, E>) => Result$1<T, E>;
declare const biMap: <S, F, T = never, E = never>(okFn: (data: T) => S, errFn: (error: E) => F) => (result: Result$1<T, E>) => Result$1<S, F>;
declare const biChain: <TS, TF, ES, EF, T = never, E = never>(okFn: (data: T) => Result$1<TS, TF>, errFn: (error: E) => Result$1<ES, EF>) => (result: Result$1<T, E>) => Result$1<TS | ES, TF | EF>;
declare const asTuple: <T, E>(result: Result$1<T, E>) => [ok: true, error: undefined, value: T] | [ok: false, error: E, value: undefined];

declare const thenMap: <T, S>(fn: (data: T) => S) => <E>(asyncRes: AsyncResult<T, E>) => AsyncResult<S, E>;
declare const thenMapErr: <E, F>(fn: (error: E) => F) => <T>(asyncRes: AsyncResult<T, E>) => AsyncResult<T, F>;
declare const thenChain: <T, S, F>(next: (data: T) => MaybeAsyncResult<S, F>) => <E>(asyncRes: AsyncResult<T, E>) => AsyncResult<T | S, E | F>;
declare const thenChainErr: <E, F, S>(next: (error: E) => MaybeAsyncResult<S, F>) => <T>(asyncRes: AsyncResult<T, E>) => AsyncResult<T | S, E | F>;
declare const thenMatch: <T, E, TR, ER>(okMatcher: (data: T) => TR, errMatcher: (error: E) => ER) => (asyncRes: AsyncResult<T, E>) => Promise<ER | TR>;
declare const thenUnwrap: <E, T>(asyncRes: AsyncResult<T, E>) => Promise<T>;
declare const thenUnwrapOr: <E, T, S>(fallback: S) => (asyncRes: AsyncResult<T, E>) => Promise<T | S>;
declare const thenUnwrapOrElse: <E, T, S>(fallback: (error: E) => S) => (asyncRes: AsyncResult<T, E>) => Promise<T | S>;
declare const thenUnwrapOrReject: <T, E>(asyncRes: AsyncResult<T, E>) => Promise<T>;
declare const thenUnwrapErr: <T, E>(asyncRes: AsyncResult<T, E>) => Promise<E>;
declare const thenUnwrapErrOr: <T, E, F>(fallback: F) => (asyncRes: AsyncResult<T, E>) => Promise<E | F>;
declare const thenUnwrapErrOrElse: <T, F>(fallback: (data: T) => F) => <E>(asyncRes: AsyncResult<T, E>) => Promise<E | F>;
declare const thenTap: <E, T>(fn: (data: T) => void) => (asyncRes: AsyncResult<T, E>) => AsyncResult<T, E>;
declare const thenTapAndWait: <E, T>(fn: (data: T) => Promise<void>) => (asyncRes: AsyncResult<T, E>) => AsyncResult<T, E>;
declare const thenTapErr: <E, T>(fn: (error: E) => void) => (asyncRes: AsyncResult<T, E>) => AsyncResult<T, E>;
declare const thenTapErrAndWait: <E, T>(fn: (error: E) => Promise<void>) => (asyncRes: AsyncResult<T, E>) => AsyncResult<T, E>;
declare const flip: <E, T>(result: Result$1<T | Promise<T>, E | Promise<E>>) => AsyncResult<T, E>;
declare const from: <T, E>(result: Result$1<T, E>) => AsyncResult<T, E>;
declare const thenUnpack: <E, T>(asyncRes: AsyncResult<T, E>) => Promise<E | T>;
type ResolveAwaitedOks<P extends readonly any[]> = {
    [K in keyof P]: P[K] extends Awaited<Result$1<infer T, any>> ? T : P[K];
};

declare const error: <E>(error: E) => ErrResult<E>;
declare const asyncError: <E>(error: E | Promise<E>) => AsyncErr<E>;

type Result<T, E> = Result$1<T, E>;
declare const Result: {
    ok: <T>(value: T) => OkResult<T>;
    asyncOk: <T>(value: T | Promise<T>) => AsyncOk<T>;
    err: <E>(error: E) => ErrResult<E>;
    error: <E>(error: E) => ErrResult<E>;
    asyncErr: <E>(error: E | Promise<E>) => AsyncErr<E>;
    asyncError: <E>(error: E | Promise<E>) => AsyncErr<E>;
    try: typeof rTry;
};

export { type AsyncResult, Do, type ErrResult, type ErrTypeOf, type MaybeAsync, type MaybeAsyncResult, type OkResult, type OkTypeOf, type ResolveAwaitedOks, Result, type ResultOf, asTuple, asyncErr, asyncError, asyncOk, biChain, biMap, chain, chainErr, collect, collectAll, collectAsync, collectErr, ensureResult, err, error, expect, expectExists, flip, from, isErr, isError, isOk, isResult, map, mapErr, match, ok, okIf, okIfExists, partition, reduce, reduceErr, separate, sequence, sequenceAsync, tap, tapErr, thenChain, thenChainErr, thenMap, thenMapErr, thenMatch, thenTap, thenTapAndWait, thenTapErr, thenTapErrAndWait, thenUnpack, thenUnwrap, thenUnwrapErr, thenUnwrapErrOr, thenUnwrapErrOrElse, thenUnwrapOr, thenUnwrapOrElse, thenUnwrapOrReject, unpack, unwrap, unwrapErr, unwrapErrOr, unwrapErrOrElse, unwrapOr, unwrapOrElse, unwrapOrThrow };