resultar 2.0.0 → 3.0.0-alpha.2

package/dist/index.d.ts

@@ -1,5 +1,624 @@
-import { S as unit, _ as err, a as fromPromise, b as safeTry, c as okAsync, d as DisposableResult, f as ErrResult, g as StrictResult, h as ResultOperations, i as errAsync, l as tryCatchAsync, m as Result, n as ResultAsync, o as fromSafePromise, p as OkResult, r as StrictResultAsync, s as fromThrowableAsync, t as DisposableResultAsync, u as unitAsync, v as fromThrowable, x as tryCatch, y as ok } from "./result-async-CxGBicja.js";
-
+//#region src/error.d.ts
+interface ErrorConfig {
+  withStackTrace: boolean;
+}
+//#endregion
+//#region src/pipe.d.ts
+type PipeFn<Input, Output> = (input: Input) => Output;
+declare abstract class Pipeable {
+  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;
+}
+//#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/tagged-types.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$1<E, Tag extends string> = Extract<E, {
+  readonly _tag: Tag;
+}>;
+type ExcludeTag<E, Tag extends string> = Exclude<E, {
+  readonly _tag: Tag;
+}>;
+type UntaggedError$1<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, R> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => R : never };
+type ResultCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown>>;
+type ResultAsyncCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown> | ResultAsync<unknown, unknown>>;
+type MatchTagHandlers<E, Handlers> = { readonly [Tag in ErrorTagsOf<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<E> | "Error" ? Handlers[Tag] : never };
+type PartialMatchTagHandlers<E, Handlers> = { readonly [Tag in keyof Handlers]: Tag extends ErrorTagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => unknown : Tag extends "Error" ? (error: Extract<E, Error>) => unknown : never };
+//#endregion
+//#region src/result.d.ts
+type ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void;
+type MatchOkHandler<T, A> = (value: T) => A;
+type MatchErrorHandler<E, B> = (error: E) => B;
+type ResultCandidate = () => Result<unknown, unknown>;
+type ResultLoopCollected<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
+type ResultLoopDiscarded<R extends Result<unknown, unknown>> = Result<void, InferErrTypes<R>>;
+type ResultIterated<State, R extends Result<State, unknown>> = Result<State, InferErrTypes<R>>;
+type ResultForEachCollected<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
+type ResultForEachDiscarded<R extends Result<unknown, unknown>> = Result<void, InferErrTypes<R>>;
+type ResultValidatedAll<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>[]>;
+type ResultZipped<Left extends Result<unknown, unknown>, Right extends Result<unknown, unknown>> = Result<[InferOkTypes<Left>, InferOkTypes<Right>], InferErrTypes<Left> | InferErrTypes<Right>>;
+type ResultBooleanCondition = boolean | (() => boolean);
+type ResultIf<ConditionErr, OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>> = Result<InferOkTypes<OnTrue> | InferOkTypes<OnFalse>, ConditionErr | InferErrTypes<OnTrue> | InferErrTypes<OnFalse>>;
+type ResultWhen<R extends Result<unknown, unknown>> = Result<InferOkTypes<R> | undefined, InferErrTypes<R>>;
+type ResultWhenWithCondition<Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>> = Result<InferOkTypes<R> | undefined, InferErrTypes<Condition> | InferErrTypes<R>>;
+type WidenLiteral$1<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
+interface MatchHandlers$1<T, E, A, B = A> {
+  readonly error: MatchErrorHandler<E, B>;
+  readonly ok: MatchOkHandler<T, A>;
+}
+type FirstSuccessOf<Candidates extends Iterable<ResultCandidate>> = Result<InferOkTypes<ReturnType<IterableElement$1<Candidates>>>, InferErrTypes<ReturnType<IterableElement$1<Candidates>>>>;
+type IterableElement$1<T> = T extends Iterable<infer Element> ? Element : never;
+interface ResultLoopOptions<State, BodyState extends State, R extends Result<unknown, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly discard?: false;
+  readonly step: (state: BodyState) => State;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultLoopBooleanOptions<State, R extends Result<unknown, unknown>> {
+  readonly body: (state: State) => R;
+  readonly discard?: false;
+  readonly step: (state: State) => State;
+  readonly while: (state: State) => boolean;
+}
+interface ResultLoopDiscardOptions<State, BodyState extends State, R extends Result<unknown, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly discard: true;
+  readonly step: (state: BodyState) => State;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultLoopBooleanDiscardOptions<State, R extends Result<unknown, unknown>> {
+  readonly body: (state: State) => R;
+  readonly discard: true;
+  readonly step: (state: State) => State;
+  readonly while: (state: State) => boolean;
+}
+interface ResultIterateOptions<State, BodyState extends State, R extends Result<State, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultIterateBooleanOptions<State, R extends Result<State, unknown>> {
+  readonly body: (state: State) => R;
+  readonly while: (state: State) => boolean;
+}
+interface ResultForEachOptions {
+  readonly discard?: false;
+}
+interface ResultForEachDiscardOptions {
+  readonly discard: true;
+}
+interface ResultIfOptions<OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>> {
+  readonly onFalse: () => OnFalse;
+  readonly onTrue: () => OnTrue;
+}
+/**
+* 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>;
+  as<X>(value: 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<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>;
+  catchTags<const Handlers extends object>(handlers: Handlers & ResultCatchTagHandlers<E, Handlers>): Result<T | InferOkTypes<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<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>(handlers: MatchHandlers$1<T, E, A, B>): A | B;
+  match<A, B = A>(fnOk: MatchOkHandler<T, A>, fnErr: MatchErrorHandler<E, B>): A | B;
+  matchTags<A, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & MatchTagHandlers<E, Handlers>): A | MatchTagHandlerResult<Handlers>;
+  matchTagsPartial<A, B, const Handlers extends object>(fnOk: (t: T) => A, handlers: Handlers & PartialMatchTagHandlers<E, Handlers>, fallback: (error: E) => B): A | MatchTagHandlerResult<Handlers> | B;
+  pipe<A>(ab: PipeFn<Result<T, E>, A>): A;
+  pipe<A, B>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>): B;
+  pipe<A, B, C>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>, cd: PipeFn<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 TryResultOptions<T, E = unknown> {
+  readonly try: () => Exclude<T, Promise<unknown>>;
+  readonly catch?: (e: unknown) => E;
+}
+interface SafeTryOptions<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr = never> {
+  readonly try: () => Generator<YieldErr, GeneratorReturnResult>;
+  readonly catch?: (e: unknown) => CatchErr;
+}
+interface SafeTryAsyncOptions<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr = never> {
+  readonly try: () => AsyncGenerator<YieldErr, GeneratorReturnResult>;
+  readonly catch?: (e: unknown) => CatchErr;
+}
+interface ResultStatic {
+  [Symbol.hasInstance](value: unknown): boolean;
+  /**
+  * Compatibility alias. Prefer the top-level `tryResult` helper in new code.
+  */
+  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>;
+  validateAll<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
+  validateAll<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
+  validateAll<Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R): ResultValidatedAll<R>;
+  zip<Left extends Result<unknown, unknown>, Right extends Result<unknown, unknown>>(this: void, left: Left, right: Right): ResultZipped<Left, Right>;
+  firstSuccessOf<Candidates extends Iterable<ResultCandidate>>(this: void, candidates: Candidates): FirstSuccessOf<Candidates>;
+  if<OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, options: ResultIfOptions<OnTrue, OnFalse>): ResultIf<never, OnTrue, OnFalse>;
+  if<Condition extends Result<boolean, unknown>, OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>>(this: void, condition: Condition, options: ResultIfOptions<OnTrue, OnFalse>): ResultIf<InferErrTypes<Condition>, OnTrue, OnFalse>;
+  when<R extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, body: () => R): ResultWhen<R>;
+  whenResult<Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(this: void, condition: Condition, body: () => R): ResultWhenWithCondition<Condition, R>;
+  unless<R extends Result<unknown, unknown>>(this: void, condition: ResultBooleanCondition, body: () => R): ResultWhen<R>;
+  unlessResult<Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(this: void, condition: Condition, body: () => R): ResultWhenWithCondition<Condition, R>;
+  loop<State, BodyState extends State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopOptions<State, BodyState, R>): ResultLoopCollected<R>;
+  loop<State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopBooleanOptions<State, R>): ResultLoopCollected<R>;
+  loop<State, BodyState extends State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopDiscardOptions<State, BodyState, R>): ResultLoopDiscarded<R>;
+  loop<State, R extends Result<unknown, unknown>>(this: void, initial: State, options: ResultLoopBooleanDiscardOptions<State, R>): ResultLoopDiscarded<R>;
+  iterate<State, BodyState extends WidenLiteral$1<State>, R extends Result<WidenLiteral$1<State>, unknown>>(this: void, initial: State, options: ResultIterateOptions<WidenLiteral$1<State>, BodyState, R>): ResultIterated<WidenLiteral$1<State>, R>;
+  iterate<State, R extends Result<WidenLiteral$1<State>, unknown>>(this: void, initial: State, options: ResultIterateBooleanOptions<WidenLiteral$1<State>, R>): ResultIterated<WidenLiteral$1<State>, R>;
+  forEach<Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultForEachOptions): ResultForEachCollected<R>;
+  forEach<Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options: ResultForEachDiscardOptions): ResultForEachDiscarded<R>;
+}
+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, CatchErr = E>(input: SafeTryOptions<Result<never, E>, Result<T, E>, CatchErr> & {
+  readonly catch: (e: unknown) => CatchErr;
+}): Result<T, E | CatchErr>;
+declare function safeTry<T, E>(input: (() => Generator<Result<never, E>, Result<T, E>>) | SafeTryOptions<Result<never, E>, Result<T, E>>): Result<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
+  readonly catch: (e: unknown) => CatchErr;
+}): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(input: (() => Generator<YieldErr, GeneratorReturnResult>) | SafeTryOptions<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, CatchErr = E>(input: SafeTryAsyncOptions<Result<never, E>, Result<T, E>, CatchErr> & {
+  readonly catch: (e: unknown) => CatchErr;
+}): ResultAsync<T, E | CatchErr>;
+declare function safeTry<T, E>(input: (() => AsyncGenerator<Result<never, E>, Result<T, E>>) | SafeTryAsyncOptions<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>, CatchErr>(input: SafeTryAsyncOptions<YieldErr, GeneratorReturnResult, CatchErr> & {
+  readonly catch: (e: unknown) => CatchErr;
+}): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(input: (() => AsyncGenerator<YieldErr, GeneratorReturnResult>) | SafeTryAsyncOptions<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 tryResult<T, E>(fn: () => Exclude<T, Promise<unknown>>, errorFn: (e: unknown) => E): Result<T, E>;
+declare function tryResult<T, E>(options: TryResultOptions<T, E> & {
+  readonly catch: (e: unknown) => E;
+}): Result<T, E>;
+declare function tryResult<T>(input: (() => Exclude<T, Promise<unknown>>) | TryResultOptions<T>): Result<T, unknown>;
+declare function unit<E = never>(): OkResult<undefined, E>;
+/** Compatibility alias. Prefer `tryResult` in new code. */
+declare const tryCatch: typeof tryResult;
+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 ResultAsyncFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void | Promise<void>;
+interface TryResultAsyncOptions<T, E = unknown> {
+  readonly try: () => Promise<T>;
+  readonly catch?: (e: unknown) => E;
+}
+type HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>;
+type HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>;
+type IterableElement<T> = T extends Iterable<infer Element> ? Element : never;
+type ResultAsyncCandidate = () => ResultAsync<unknown, unknown>;
+type FirstSuccessOfAsync<Candidates extends Iterable<ResultAsyncCandidate>> = ResultAsync<InferAsyncOkTypes<ReturnType<IterableElement<Candidates>>>, InferAsyncErrTypes<ReturnType<IterableElement<Candidates>>>>;
+type ResultAsyncLoopCollected<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>;
+type ResultAsyncLoopDiscarded<R extends ResultAsync<unknown, unknown>> = ResultAsync<void, InferAsyncErrTypes<R>>;
+type ResultAsyncIterated<State, R extends ResultAsync<State, unknown>> = ResultAsync<State, InferAsyncErrTypes<R>>;
+type ResultAsyncForEachCollected<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>;
+type ResultAsyncForEachDiscarded<R extends ResultAsync<unknown, unknown>> = ResultAsync<void, InferAsyncErrTypes<R>>;
+type ResultAsyncValidatedAll<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>;
+type ResultAsyncZipped<Left extends ResultAsync<unknown, unknown>, Right extends ResultAsync<unknown, unknown>> = ResultAsync<[InferAsyncOkTypes<Left>, InferAsyncOkTypes<Right>], InferAsyncErrTypes<Left> | InferAsyncErrTypes<Right>>;
+type ResultAsyncBooleanCondition = boolean | (() => boolean);
+type ResultAsyncConditional = Result<unknown, unknown> | ResultAsync<unknown, unknown>;
+type ResultAsyncConditionResult = Result<boolean, unknown> | ResultAsync<boolean, unknown>;
+type ResultAsyncIf<ConditionErr, OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional> = ResultAsync<HandlerOk<OnTrue> | HandlerOk<OnFalse>, ConditionErr | HandlerErr<OnTrue> | HandlerErr<OnFalse>>;
+type ResultAsyncWhen<R extends ResultAsyncConditional> = ResultAsync<HandlerOk<R> | undefined, HandlerErr<R>>;
+type ResultAsyncWhenWithCondition<Condition extends ResultAsyncConditionResult, R extends ResultAsyncConditional> = ResultAsync<HandlerOk<R> | undefined, HandlerErr<Condition> | HandlerErr<R>>;
+type WidenLiteral<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
+interface ResultAsyncLoopOptions<State, BodyState extends State, R extends ResultAsync<unknown, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly discard?: false;
+  readonly step: (state: BodyState) => State;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultAsyncLoopBooleanOptions<State, R extends ResultAsync<unknown, unknown>> {
+  readonly body: (state: State) => R;
+  readonly discard?: false;
+  readonly step: (state: State) => State;
+  readonly while: (state: State) => boolean;
+}
+interface ResultAsyncLoopDiscardOptions<State, BodyState extends State, R extends ResultAsync<unknown, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly discard: true;
+  readonly step: (state: BodyState) => State;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultAsyncLoopBooleanDiscardOptions<State, R extends ResultAsync<unknown, unknown>> {
+  readonly body: (state: State) => R;
+  readonly discard: true;
+  readonly step: (state: State) => State;
+  readonly while: (state: State) => boolean;
+}
+interface ResultAsyncIterateOptions<State, BodyState extends State, R extends ResultAsync<State, unknown>> {
+  readonly body: (state: BodyState) => R;
+  readonly while: (state: State) => state is BodyState;
+}
+interface ResultAsyncIterateBooleanOptions<State, R extends ResultAsync<State, unknown>> {
+  readonly body: (state: State) => R;
+  readonly while: (state: State) => boolean;
+}
+interface ResultAsyncForEachOptions {
+  readonly discard?: false;
+}
+interface ResultAsyncForEachDiscardOptions {
+  readonly discard: true;
+}
+interface ResultAsyncIfOptions<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional> {
+  readonly onFalse: () => OnFalse;
+  readonly onTrue: () => OnTrue;
+}
+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> extends Pipeable 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.
+  *
+  * Compatibility alias. Prefer the top-level `tryResultAsync` helper in new code.
+  *
+  * @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.
+  *
+  * New code should use the top-level `tryResultAsync` helper instead.
+  */
+  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>;
+  static validateAll<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  static validateAll<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  static validateAll<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R): ResultAsyncValidatedAll<R>;
+  static zip<Left extends ResultAsync<unknown, unknown>, Right extends ResultAsync<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsyncZipped<Left, Right>;
+  static firstSuccessOf<Candidates extends Iterable<ResultAsyncCandidate>>(this: void, candidates: Candidates): FirstSuccessOfAsync<Candidates>;
+  static if<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<never, OnTrue, OnFalse>;
+  static if<Condition extends ResultAsyncConditionResult, OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: Condition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse>;
+  static when<R extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, body: () => R): ResultAsyncWhen<R>;
+  static whenResult<Condition extends ResultAsyncConditionResult, R extends ResultAsyncConditional>(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R>;
+  static unless<R extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, body: () => R): ResultAsyncWhen<R>;
+  static unlessResult<Condition extends ResultAsyncConditionResult, R extends ResultAsyncConditional>(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R>;
+  static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopOptions<State, BodyState, R>): ResultAsyncLoopCollected<R>;
+  static loop<State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopBooleanOptions<State, R>): ResultAsyncLoopCollected<R>;
+  static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopDiscardOptions<State, BodyState, R>): ResultAsyncLoopDiscarded<R>;
+  static loop<State, R extends ResultAsync<unknown, unknown>>(this: void, initial: State, options: ResultAsyncLoopBooleanDiscardOptions<State, R>): ResultAsyncLoopDiscarded<R>;
+  static iterate<State, BodyState extends WidenLiteral<State>, R extends ResultAsync<WidenLiteral<State>, unknown>>(this: void, initial: State, options: ResultAsyncIterateOptions<WidenLiteral<State>, BodyState, R>): ResultAsyncIterated<WidenLiteral<State>, R>;
+  static iterate<State, R extends ResultAsync<WidenLiteral<State>, unknown>>(this: void, initial: State, options: ResultAsyncIterateBooleanOptions<WidenLiteral<State>, R>): ResultAsyncIterated<WidenLiteral<State>, R>;
+  static forEach<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultAsyncForEachOptions): ResultAsyncForEachCollected<R>;
+  static forEach<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options: ResultAsyncForEachDiscardOptions): ResultAsyncForEachDiscarded<R>;
+  /**
+  * 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>;
+  as<X>(value: 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$1<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$1<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$1<E, Tag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeTag<E, Tag> | F>;
+  catchTags<const Handlers extends object>(handlers: Handlers & ResultAsyncCatchTagHandlers<E, Handlers>): ResultAsync<T | HandlerOk<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>>;
+  match<A, B = A>(handlers: MatchHandlers$1<T, E, A, B>): Promise<A | B>;
+  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>;
+  /**
+  * 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 function tryResultAsync<T, E>(fn: Promise<T> | (() => Promise<T>), errorFn: (e: unknown) => E): ResultAsync<T, E>;
+declare function tryResultAsync<T, E>(options: TryResultAsyncOptions<T, E> & {
+  readonly catch: (e: unknown) => E;
+}): ResultAsync<T, E>;
+declare function tryResultAsync<T>(input: Promise<T> | (() => Promise<T>) | TryResultAsyncOptions<T>): ResultAsync<T, unknown>;
+/** Compatibility alias. Prefer `tryResultAsync` in new code. */
+declare const tryCatchAsync: typeof tryResultAsync;
+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
 //#region src/tagged-error.d.ts
 type Alpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_";
 type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
@@ -73,5 +692,5 @@ declare function createTaggedError<const Tag extends string, const MessageTempla
 declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: MatchHandlers<ErrorType, ReturnType>) => ReturnType;
 declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, Result, ResultAsync, type ResultOperations, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryCatch, tryCatchAsync, unit, unitAsync };
+export { DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, Result, ResultAsync, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
 //# sourceMappingURL=index.d.ts.map