@rustresult/result/lib/RustlikeResultAsync.d.ts

Rust-like Result and ResultAsync for Javascript

import type { Result } from './Result';
import type { ResultAsync } from './ResultAsync';
import type { Optional } from './types.internal';
export declare class RustlikeResultAsync<T, E> implements ResultAsync<T, E> {
    private readonly _promise;
    constructor(promise: Result<T, E> | Promise<Result<T, E>> | ResultAsync<T, E>);
    isOk(): Promise<boolean>;
    isOkAnd(fn: (value: T) => boolean | Promise<boolean>): Promise<boolean>;
    isErr(): Promise<boolean>;
    isErrAnd(fn: (err: E) => boolean | Promise<boolean>): Promise<boolean>;
    ok(): Promise<Optional<T>>;
    err(): Promise<Optional<E>>;
    map<U>(op: (value: T) => U | Promise<U>): ResultAsync<U, E>;
    mapOr<U>(fallback: U, map: (value: T) => U | Promise<U>): Promise<U>;
    mapOrElse<U>(fallback: (err: E) => U | Promise<U>, map: (value: T) => U | Promise<U>): Promise<U>;
    mapErr<F>(op: (err: E) => F | Promise<F>): ResultAsync<T, F>;
    inspect(fn: (value: T) => void | Promise<void>): ResultAsync<T, E>;
    inspectErr(fn: (err: E) => void | Promise<void>): ResultAsync<T, E>;
    expect(msg: string): Promise<T>;
    unwrap(): Promise<T>;
    expectErr(msg: string): Promise<E>;
    unwrapErr(): Promise<E>;
    unwrapOr(fallback: T): Promise<T>;
    unwrapOrElse(op: (err: E) => T | Promise<T>): Promise<T>;
    unwrapUnchecked(): Promise<T>;
    unwrapErrUnchecked(): Promise<E>;
    and<U>(res: Result<U, E> | Promise<Result<U, E>> | ResultAsync<U, E>): ResultAsync<U, E>;
    andThen<U>(op: (value: T) => Result<U, E> | Promise<Result<U, E>> | ResultAsync<U, E>): ResultAsync<U, E>;
    or<F>(res: Result<T, F> | Promise<Result<T, F>> | ResultAsync<T, F>): ResultAsync<T, F>;
    orElse<F>(op: (err: E) => Result<T, F> | Promise<Result<T, F>> | ResultAsync<T, F>): ResultAsync<T, F>;
    transpose(): Promise<Optional<Result<T & NonNullable<unknown>, E>>>;
    private static _equal;
    equal(other: Result<unknown, unknown> | Promise<Result<unknown, unknown>> | ResultAsync<unknown, unknown>): Promise<boolean>;
    then<TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
}