resultar 1.4.4 → 1.4.5

package/dist/utils.d.cts

@@ -1 +1,612 @@
-export { c as ExtractErrAsyncTypes, b as ExtractErrTypes, a as ExtractOkAsyncTypes, E as ExtractOkTypes, f as InferAsyncErrTypes, e as InferAsyncOkTypes, d as InferErrTypes, I as InferOkTypes, h as combineResultAsyncList, j as combineResultAsyncListWithAllErrors, g as combineResultList, i as combineResultListWithAllErrors } from './index-lTU9Lum3.cjs';
+type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never;
+};
+type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never;
+};
+type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never;
+};
+type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never;
+};
+type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
+type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
+type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
+type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
+/**
+ * Short circuits on the FIRST Err value that we find
+ */
+declare const combineResultList: <T, E>(resultList: readonly Result<T, E>[]) => Result<readonly T[], E>;
+declare const combineResultAsyncList: <T, E>(asyncResultList: readonly ResultAsync<T, E>[]) => ResultAsync<readonly T[], E>;
+/**
+ * Give a list of all the errors we find
+ */
+declare const combineResultListWithAllErrors: <T, E>(resultList: readonly Result<T, E>[]) => Result<readonly T[], E[]>;
+declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: readonly ResultAsync<T, E>[]) => ResultAsync<readonly T[], E[]>;
+
+declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+}
+/**
+ * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
+ * This class provides a way to handle asynchronous operations that may succeed with a value of type T
+ * or fail with an error of type E.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ *
+ * @implements {PromiseLike<Result<T, E>>}
+ *
+ * @example
+ * ```typescript
+ * // Create a successful async result
+ * const okAsync = ResultAsync.okAsync(42);
+ *
+ * // Create a failed async result
+ * const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
+ *
+ * // Transform a Promise into a ResultAsync
+ * const resultFromPromise = ResultAsync.fromPromise(
+ *   fetch("https://api.example.com/data"),
+ *   (error) => new Error(`API call failed: ${error}`)
+ * );
+ * ```
+ *
+ * @remarks
+ * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
+ * It provides various utility methods for transforming and combining results, similar to the Result type,
+ * but operating in an asynchronous context.
+ *
+ * The class includes methods for:
+ * - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
+ * - Transforming values (map, mapErr)
+ * - Chaining operations (andThen, orElse)
+ * - Error handling (tapError)
+ * - Conditional branching (if)
+ * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
+ */
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    /**
+     * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).
+     *
+     * @param {T} value - The value to be wrapped in a Result.ok.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.
+     */
+    static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+    static okAsync<T extends void = void, E = never>(value: void): ResultAsync<void, E>;
+    /**
+     * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
+     *
+     * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
+     */
+    static unitAsync<E = never>(): ResultAsync<undefined, E>;
+    /**
+     * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).
+     *
+     * @param {E} error - The error to be wrapped in a Result.err.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.
+     */
+    static errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E>;
+    static errAsync<T = never, E extends void = void>(err: void): ResultAsync<T, void>;
+    /**
+     * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
+     *
+     * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.
+     * @param errorFn - Optional function to transform the caught error into a specific error type.
+     *                  If not provided, the original error will be used.
+     * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
+     *          or Err with either the transformed error (if errorFn is provided) or the original error.
+     *
+     * @example
+     * ```typescript
+     * // Without error transformer
+     * const result = ResultAsync.tryCatch(Promise.resolve(42));
+     *
+     * // With error transformer
+     * const result = ResultAsync.tryCatch(
+     *   fetch('https://api.example.com'),
+     *   (error) => new CustomError('API request failed')
+     * );
+     * ```
+     */
+    static tryCatch<T, E>(fn: Promise<T> | (() => Promise<T>), errorFn?: (e: unknown) => E): ResultAsync<T, E>;
+    /**
+     * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+     * based on the provided promise.
+     *
+     * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
+     */
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    /**
+     * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+     * based on the provided promise.
+     *
+     * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+     * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
+     */
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    /**
+     * Wraps a async function with a try catch, creating a new function with the same
+     * arguments but returning `Ok` if successful, `Err` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     * @returns a new function that returns a `ResultAsync`
+     */
+    static fromThrowable<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
+    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    if(fCondition: (t: T) => boolean): {
+        true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
+            false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
+        };
+    };
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+    match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
+    unwrapOr<A>(t: A): Promise<T | A>;
+    unwrapOrThrow(): Promise<T>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Err` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Err`
+     * @returns `self` if the result is `Ok`, otherwise the result of `f`
+     * @example
+     */
+    tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
+    finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
+    [Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T>;
+    /**
+     * @deprecated will be removed in 2.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
+}
+/**
+ * @deprecated Use `safeTry` instead.
+ * @see `safeTry`
+ *
+ * This will be removed in the next major version.
+ */
+declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+declare const okAsync: typeof ResultAsync.okAsync;
+declare const errAsync: typeof ResultAsync.errAsync;
+declare const fromPromise: typeof ResultAsync.fromPromise;
+declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
+declare const unitAsync: typeof ResultAsync.unitAsync;
+declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
+declare const tryCatchAsync: typeof ResultAsync.tryCatch;
+type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
+type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends (infer A)[] ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Result<L, R>[] : never : never : never;
+type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends (infer I)[] ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+type Writable<T> = T extends readonly unknown[] ? [...T] : T;
+
+/**
+ * A Result interface that is used to define the methods that are available on a
+ * `Result` object.
+ *
+ * The immutability of the `Result` object is maintained by the interface.
+ */
+interface Resultable<T, E> {
+    get value(): T;
+    get error(): E;
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): boolean;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): boolean;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(defaultValue: A): T | A;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+/**
+ * A `Result` is a type that represents either success (`Ok`) or failure (`Err`).
+ * It is often used to replace exceptions or `null` returns.
+ * `Result` is often used to handle errors in a functional way.
+ * The `Result` type is often used to handle errors in a functional way.
+ */
+declare class Result<T, E> implements Resultable<T, E> {
+    private readonly state;
+    /**
+     * Creates a `Result` by running a function that might throw.
+     * If the function throws, the error will be caught and returned as an `Err`.
+     * If the function succeeds, the value will be wrapped in an `Ok`.
+     *
+     * @param fn - The function to execute, which might throw an error
+     * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
+     * @returns A `Result` containing either the function's return value or the caught error
+     */
+    static tryCatch<T, E>(fn: () => Exclude<T, Promise<unknown>>, errorFn?: (e: unknown) => E): Result<T, E>;
+    /**
+     * Wraps a function with a try catch, creating a new function with the same
+     * arguments but returning `Ok` if successful, `Err` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     */
+    static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    /**
+     * Creates a new `Result` instance representing a successful operation.
+     *
+     * @param {T} value - The value to be wrapped in the `Result` instance.
+     * @return {Result<T, E>} A new `Result` instance with the provided value.
+     */
+    static ok<T, E = never>(value: T): Result<T, E>;
+    static ok<T extends void = void, E = never>(value: void): Result<void, E>;
+    /**
+     * Creates a new `Result` instance representing a successful operation with an undefined value.
+     *
+     * @return {Result<undefined, E>} A new `Result` instance with an undefined value.
+     */
+    static unit<E = never>(): Result<undefined, E>;
+    static err<T = never, E extends string = string>(err: E): Result<T, E>;
+    static err<T = never, E = unknown>(err: E): Result<T, E>;
+    static err<T = never, E extends void = void>(err: void): Result<T, void>;
+    static combine<T extends readonly [
+        Result<unknown, unknown>,
+        ...Result<unknown, unknown>[]
+    ]>(resultList: T): CombineResults<T>;
+    static combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+    static combineWithAllErrors<T extends readonly [
+        Result<unknown, unknown>,
+        ...Result<unknown, unknown>[]
+    ]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    readonly value: T;
+    readonly error: E;
+    private constructor();
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): boolean;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): boolean;
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>`
+     * by applying a function to a contained `Ok` value, leaving an `Err` value
+     * untouched.
+     *
+     * @param f The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    map<X>(f: (t: T) => X): Result<X, E>;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+     * contained `Err` value, leaving an `Ok` value untouched.
+     *
+     * This function can be used to pass through a successful result while
+     * handling an error.
+     *
+     * @param f a function to apply to the error `Err` value
+     */
+    mapErr<X>(fn: (t: E) => X): Result<T, X>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent computation using the
+     * inner `T` value, but that computation might fail.
+     * Additionally, `andThen` is really useful as a tool to flatten a
+     * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
+     *
+     * @param f The function to apply to the current value
+     */
+    andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y>;
+    if(fCondition: (t: T) => boolean): {
+        true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => {
+            false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E>;
+        };
+    };
+    /**
+     * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
+     *
+     * This is useful for error recovery.
+     *
+     * @param f  A function to apply to an `Err` value, leaving `Ok` values
+     * untouched.
+     */
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    /**
+     * Similar to `map` Except you must return a new `Result`.
+     *
+     * This is useful for when you need to do a subsequent async computation using
+     * the inner `T` value, but that computation might fail. Must return a ResultAsync
+     *
+     * @param f The function that returns a `ResultAsync` to apply to the current
+     * value
+     */
+    asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
+    /**
+     * Maps a `Result<T, E>` to `ResultAsync<U, E>`
+     * by applying an async function to a contained `Ok` value, leaving an `Err`
+     * value untouched.
+     *
+     * @param f An async function to apply an `OK` value
+     */
+    asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(defaultValue: A): T | A;
+    /**
+     * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
+     * execute the function that matches the `Result` variant.
+     *
+     * Match callbacks do not necessitate to return a `Result`, however you can
+     * return a `Result` if you want to.
+     *
+     * `match` is like chaining `map` and `mapErr`, with the distinction that
+     * with `match` both functions must have the same return type.
+     *
+     * @param ok
+     * @param err
+     */
+    match<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B;
+    /**
+     * Performs a side effect for the `Ok` or `Err` variant of `Result`.
+     *
+     * @param fn The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    log(fn: (t?: T, e?: E) => void): this;
+    /**
+     * Performs a side effect for the `Ok` variant of `Result`.
+     *
+     * @param fn The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    tap(fn: (t: T) => void): this;
+    /**
+     * Performs a side effect for the `Err` variant of `Result`.
+     *
+     * @param fn The function to apply an `Err` value
+     * @returns the result of applying `f` or an `Ok` untouched
+     */
+    tapError(fn: (e: E) => void): this;
+    /**
+     * This method is used to clean up and release any resources that the `Result`
+     * @param f The function that will be called to clean up the resources
+     */
+    finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
+    unwrapOrThrow(): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Result<never, E>, T>;
+    safeUnwrap(): Generator<Result<never, E>, T>;
+}
+/**
+ * A `Disposable` is an object that has a `dispose` method that can be used to
+ * clean up resources.
+ */
+declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
+    readonly result: Resultable<T, E>;
+    private readonly finalizer;
+    constructor(result: Resultable<T, E>, finalizer: (value: T, error: E) => void);
+    get value(): T;
+    get error(): E;
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+    isOk(): boolean;
+    isErr(): boolean;
+    unwrapOr<A>(defaultValue: A): T | A;
+    [Symbol.dispose](): void;
+}
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
+ * Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => Generator<YieldErr, GeneratorReturnResult>): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and
+ * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+declare const fromThrowable: typeof Result.fromThrowable;
+declare const unit: typeof Result.unit;
+declare const tryCatch: typeof Result.tryCatch;
+type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    ...0[]
+];
+type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [
+    Depth
+] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [
+    ...Collected,
+    [L, R]
+], Prev[Depth]> : never : Collected;
+type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [
+    infer L,
+    infer R
+] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR> : T;
+type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W] : [];
+type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+type IsLiteralArray<T> = T extends {
+    length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
+type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
+
+interface ErrorConfig {
+    withStackTrace: boolean;
+}
+interface ResultarError<T, E> extends Error {
+    data: {
+        type: string;
+        value: T | undefined;
+    } | {
+        type: string;
+        value: E | undefined;
+    };
+    message: string;
+    stack: string | undefined;
+}
+declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
+
+export { type CombineResultAsyncs as C, DisposableResultAsync as D, type EmptyArrayToNever as E, type ExtractErrAsyncTypes, type ExtractErrTypes, type ExtractOkAsyncTypes, type ExtractOkTypes, type IsLiteralArray as I, type InferAsyncErrTypes, type InferAsyncOkTypes, type InferErrTypes, type InferOkTypes, type MemberListOf as M, ResultAsync as R, type Transpose as T, fromSafePromise as a, fromThrowableAsync as b, type CombineResultsWithAllErrorsArrayAsync as c, combineResultAsyncList, combineResultAsyncListWithAllErrors, combineResultList, combineResultListWithAllErrors, Result as d, errAsync as e, fromPromise as f, DisposableResult as g, safeTry as h, ok as i, err as j, fromThrowable as k, unit as l, tryCatch as m, type Combine as n, okAsync as o, type Dedup as p, type MembersToUnion as q, type CombineResults as r, safeTryAsync as s, tryCatchAsync as t, unitAsync as u, type CombineResultsWithAllErrorsArray as v, type ErrorConfig as w, createResultarError as x };