typed-utilities/build/Result.d.ts

Strongly typed general purpose utilities

import { Left, Right } from "./Either";
export declare type Ok<Value = unknown> = Left<Value>;
export declare type Err<Error = unknown> = Right<Error>;
export declare type Result<Value = unknown, Error = unknown> = Ok<Value> | Err<Error>;
declare function isOk<Value = unknown>(result: Result<Value, unknown>): result is Ok<Value>;
declare function assertOk<Value = unknown>(result: Result<Value, unknown>, message?: string): asserts result is Ok<Value>;
declare function isErr<Error = unknown>(result: Result<unknown, Error>): result is Err<Error>;
declare function assertErr<Error = unknown>(result: Result<unknown, Error>, message?: string): asserts result is Err<Error>;
declare type Match<IfOk, IfErr, Value = unknown, Error = unknown> = {
    readonly ok: (value: Value) => IfOk;
    readonly err: (error: Error) => IfErr;
};
export declare const Result: {
    is: {
        ok: typeof isOk;
        err: typeof isErr;
    };
    assert: {
        ok: typeof assertOk;
        err: typeof assertErr;
    };
    of: {
        ok: <Value = unknown>(value: Value) => Ok<Value>;
        err: <Error_1 = unknown>(error: Error_1) => Err<unknown>;
    };
    to: {
        okValue: <Value_1 = unknown>(result: Ok<Value_1>) => Value_1;
        errError: <Error_2 = unknown>(result: Err<Error_2>) => Error_2;
    };
    match: <IfOk, IfErr, Value_2 = unknown, Error_3 = unknown>(result: Result<Value_2, Error_3>, match: Match<IfOk, IfErr, Value_2, Error_3>) => IfOk | IfErr;
    tryCatch: <T>(fn: () => T) => Result<T, unknown>;
    tryCatchAsync: <T_1>(fn: () => Promise<T_1>) => Promise<Result<T_1, unknown>>;
};
export {};