resultar 2.0.0 → 3.0.0-alpha.2

package/dist/result-async-CxGBicja.d.ts

@@ -1,439 +0,0 @@
-//#region src/error.d.ts
-interface ErrorConfig {
-  withStackTrace: boolean;
-}
-//#endregion
-//#region src/utils.d.ts
-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;
-//#endregion
-//#region src/result.d.ts
-type TaggedValue$1 = {
-  readonly _tag: string;
-};
-type TaggedErrorValue$1 = Error & TaggedValue$1;
-type TagsOf$1<E> = Extract<E, TaggedValue$1>["_tag"];
-type ErrorTagsOf$1<E> = Extract<E, TaggedErrorValue$1>["_tag"];
-type ErrorForTag$1<E, Tag extends string> = Extract<E, {
-  readonly _tag: Tag;
-}>;
-type ExcludeTag$1<E, Tag extends string> = Exclude<E, {
-  readonly _tag: Tag;
-}>;
-type UntaggedError$1<E> = Exclude<Extract<E, Error>, TaggedErrorValue$1>;
-type CatchTagHandlerResult$1<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type MatchTagHandlerResult$1<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type CatchTagHandlers$1<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf$1<E> ? (error: ErrorForTag$1<E, Tag & string>) => Result<unknown, unknown> : never };
-type MatchTagHandlers$1<E, Handlers> = { readonly [Tag in ErrorTagsOf$1<E>]: (error: ErrorForTag$1<E, Tag>) => unknown } & ([UntaggedError$1<E>] extends [never] ? {
-  readonly Error?: (error: Error) => unknown;
-} : {
-  readonly Error: (error: UntaggedError$1<E>) => unknown;
-}) & { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf$1<E> | "Error" ? Handlers[Tag] : never };
-type PartialMatchTagHandlers$1<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf$1<E> ? (error: ErrorForTag$1<E, Tag & string>) => unknown : Tag extends "Error" ? (error: Extract<E, Error>) => unknown : never };
-type PipeFn$1<Input, Output> = (input: Input) => Output;
-type ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void;
-/**
-* 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;
-}
-interface ResultOperations<T, E> {
-  isOk(): this is OkResult<T, E>;
-  isErr(): this is ErrResult<T, E>;
-  unwrapOr<A>(defaultValue: A): T | A;
-  _unsafeUnwrap(config?: ErrorConfig): T;
-  _unsafeUnwrapErr(config?: ErrorConfig): E;
-  map<X>(f: (t: T) => X): Result<X, E>;
-  filterOrElse<U extends T, F>(predicate: (value: T) => value is U, onFalse: (value: T) => F): Result<U, E | F>;
-  filterOrElse<F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>;
-  mapErr<X>(fn: (t: E) => X): Result<T, X>;
-  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>;
-    };
-  };
-  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
-  catchTag<const Tag extends TagsOf$1<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): Result<T | InferOkTypes<R>, ExcludeTag$1<E, Tag> | InferErrTypes<R>>;
-  catchTags<const Handlers extends object>(handlers: Handlers & CatchTagHandlers$1<E, Handlers>): Result<T | InferOkTypes<CatchTagHandlerResult$1<Handlers>>, ExcludeTag$1<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult$1<Handlers>>>;
-  asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
-  asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
-  match<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B;
-  matchTags<A, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & MatchTagHandlers$1<E, Handlers>): A | MatchTagHandlerResult$1<Handlers>;
-  matchTagsPartial<A, B, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & PartialMatchTagHandlers$1<E, Handlers>, fallback: (error: E) => B): A | MatchTagHandlerResult$1<Handlers> | B;
-  pipe<A>(ab: PipeFn$1<Result<T, E>, A>): A;
-  pipe<A, B>(ab: PipeFn$1<Result<T, E>, A>, bc: PipeFn$1<A, B>): B;
-  pipe<A, B, C>(ab: PipeFn$1<Result<T, E>, A>, bc: PipeFn$1<A, B>, cd: PipeFn$1<B, C>): C;
-  log(fn: (t?: T, e?: E) => void): this;
-  tap(fn: (t: T) => void): this;
-  tapError(fn: (e: E) => void): this;
-  toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E>;
-  unwrapOrThrow(): T;
-  [Symbol.iterator](): Generator<Result<never, E>, T>;
-  safeUnwrap(): Generator<Result<never, E>, T>;
-}
-interface OkResult<T, E> extends ResultOperations<T, E> {
-  readonly value: T;
-}
-interface ErrResult<T, E> extends ResultOperations<T, E> {
-  readonly error: E;
-}
-type Result<T, E> = OkResult<T, E> | ErrResult<T, E>;
-type StrictResult<T, E extends Error = Error> = Result<T, E>;
-interface ResultStatic {
-  [Symbol.hasInstance](value: unknown): boolean;
-  tryCatch<T, E>(this: void, fn: () => Exclude<T, Promise<unknown>>, errorFn?: (e: unknown) => E): Result<T, E>;
-  fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(this: void, fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-  ok<T, E = never>(this: void, value: T): OkResult<T, E>;
-  ok<E = never>(this: void, value: void): OkResult<void, E>;
-  unit<E = never>(this: void): Result<undefined, E>;
-  err<T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>;
-  err<T = never, E = unknown>(this: void, err: E): ErrResult<T, E>;
-  err<T = never>(this: void, err: void): ErrResult<T, void>;
-  combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResults<T>;
-  combine<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResults<T>;
-  combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
-  combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
-}
-declare const Result: ResultStatic;
-/**
-* 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 {
-  private disposed;
-  private readonly finalizer;
-  readonly result: Result<T, E>;
-  constructor(result: Result<T, E>, finalizer: ResultFinalizer<T, E>);
-  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()`,
-* `yield* result`, and `yield* resultAsync` 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 function ok<T, E = never>(value: T): OkResult<T, E>;
-declare function ok<E = never>(value: void): OkResult<void, E>;
-declare function err<T = never, E extends string = string>(err: E): ErrResult<T, E>;
-declare function err<T = never, E = unknown>(err: E): ErrResult<T, E>;
-declare function err<T = never>(err: void): ErrResult<T, void>;
-declare const fromThrowable: typeof Result.fromThrowable;
-declare function unit<E = never>(): OkResult<undefined, E>;
-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][]>;
-//#endregion
-//#region src/result-async.d.ts
-type TaggedValue = {
-  readonly _tag: string;
-};
-type TaggedErrorValue = Error & TaggedValue;
-type TagsOf<E> = Extract<E, TaggedValue>["_tag"];
-type ErrorTagsOf<E> = Extract<E, TaggedErrorValue>["_tag"];
-type ErrorForTag<E, Tag extends string> = Extract<E, {
-  readonly _tag: Tag;
-}>;
-type ExcludeTag<E, Tag extends string> = Exclude<E, {
-  readonly _tag: Tag;
-}>;
-type UntaggedError<E> = Exclude<Extract<E, Error>, TaggedErrorValue>;
-type CatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type MatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
-type CatchTagHandlers<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf<E> ? (error: ErrorForTag<E, Tag & string>) => Result<unknown, unknown> | ResultAsync<unknown, unknown> : never };
-type MatchTagHandlers<E, Handlers> = { readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag<E, Tag>) => unknown } & ([UntaggedError<E>] extends [never] ? {
-  readonly Error?: (error: Error) => unknown;
-} : {
-  readonly Error: (error: UntaggedError<E>) => unknown;
-}) & { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> | "Error" ? Handlers[Tag] : never };
-type PartialMatchTagHandlers<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> ? (error: ErrorForTag<E, Tag & string>) => unknown : Tag extends "Error" ? (error: Extract<E, Error>) => unknown : never };
-type PipeFn<Input, Output> = (input: Input) => Output;
-type ResultAsyncFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void | Promise<void>;
-type HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>;
-type HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>;
-declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {
-  private readonly innerPromise;
-  private readonly finalizer;
-  private disposed;
-  constructor(res: Promise<Result<T, E>>, finalizer: ResultAsyncFinalizer<T, E>);
-  then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-/**
-* 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>(this: void, value: T): ResultAsync<T, E>;
-  static okAsync<E = never>(this: void, 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>(this: void): 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>(this: void, err: E): ResultAsync<T, E>;
-  static errAsync<T = never>(this: 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>(this: void, fn: Promise<T> | (() => Promise<T>)): ResultAsync<T, unknown>;
-  static tryCatch<T, E>(this: void, 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>(this: void, 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>(this: void, promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-  static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
-  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
-  static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, 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 unknown[], T, E>(this: void, 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>(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>;
-  filterOrElse<U extends T, F>(predicate: (value: T) => value is U, onFalse: (value: T) => F | Promise<F>): ResultAsync<U, E | F>;
-  filterOrElse<F>(predicate: (value: T) => boolean | Promise<boolean>, onFalse: (value: T) => F | Promise<F>): ResultAsync<T, E | F>;
-  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>;
-  catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag<E, Tag>) => R): ResultAsync<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>;
-  catchTag<const Tag extends TagsOf<E>, R extends ResultAsync<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag<E, Tag>) => R): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeTag<E, Tag> | InferAsyncErrTypes<R>>;
-  catchTag<U, F, const Tag extends TagsOf<E>>(tag: Tag, f: (error: ErrorForTag<E, Tag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeTag<E, Tag> | F>;
-  catchTags<const Handlers extends object>(handlers: Handlers & CatchTagHandlers<E, Handlers>): ResultAsync<T | HandlerOk<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>>;
-  match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
-  matchTags<A, const Handlers extends object>(ok: (t: T) => A, handlers: Handlers & MatchTagHandlers<E, Handlers>): Promise<A | MatchTagHandlerResult<Handlers>>;
-  matchTagsPartial<A, B, const Handlers extends object>(ok: (t: T) => A, handlers: Handlers & PartialMatchTagHandlers<E, Handlers>, fallback: (error: E) => B): Promise<A | MatchTagHandlerResult<Handlers> | B>;
-  unwrapOr<A>(t: A): Promise<T | A>;
-  unwrapOrThrow(): Promise<T>;
-  pipe<A>(ab: PipeFn<this, A>): A;
-  pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B;
-  pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C;
-  /**
-  * Runs a side effect for either variant and preserves the original async result.
-  *
-  * For `Ok`, the callback receives `(value, undefined)`.
-  * For `Err`, the callback receives `(undefined, error)`.
-  * Callback errors and rejected callback promises are intentionally ignored.
-  *
-  * Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should
-  * transform the result.
-  */
-  log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E>;
-  /**
-  * Runs a side effect only for the `Ok` variant and preserves the original async result.
-  *
-  * Callback errors and rejected callback promises are intentionally ignored.
-  * Use `map` or `andThen` when the callback should transform the value.
-  */
-  tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
-  /**
-  * Runs a side effect only for the `Err` variant and preserves the original async result.
-  *
-  * Callback errors and rejected callback promises are intentionally ignored.
-  * Use `mapErr` or `orElse` when the callback should transform the error.
-  */
-  tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
-  toAsyncDisposable(f: ResultAsyncFinalizer<T, E>): DisposableResultAsync<T, E>;
-  [Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T>;
-}
-type StrictResultAsync<T, E extends Error = Error> = 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;
-//#endregion
-export { unit as S, err as _, fromPromise as a, safeTry as b, okAsync as c, DisposableResult as d, ErrResult as f, StrictResult as g, ResultOperations as h, errAsync as i, tryCatchAsync as l, Result as m, ResultAsync as n, fromSafePromise as o, OkResult as p, StrictResultAsync as r, fromThrowableAsync as s, DisposableResultAsync as t, unitAsync as u, fromThrowable as v, tryCatch as x, ok as y };
-//# sourceMappingURL=result-async-CxGBicja.d.ts.map