safe-result/lib/result.d.ts

Create safe results that are either successes or failures

/**
 * A result that is either a [[`SuccessResult`]] or [[`FailureResult`]]
 * @typeParam T - Type of successful result
 * @typeParam E - Type of error result
 */
export declare type Result<T = unknown, E = Error> = SuccessResult<T> | FailureResult<E>;
/**
 * Alias for `Promise<Result<T, E>>`
 * @see [[Result]]
 * @typeParam T - Type of successful result
 * @typeParam E - Type of error result
 */
export declare type AsyncResult<T = unknown, E = Error> = Promise<Result<T, E>>;
/**
 * Result interface
 */
export interface ResultType<T, E> {
    /** The value */
    readonly result: T;
    /** The error */
    readonly error: E;
    /**
     * Returns a tuple with `[successValue, failureValue]`
     */
    unwrap(): [T, E];
    /** Returns `true` if a success result, `false` otherwise` */
    success: boolean;
    /** Returns `true` if an error result, `false` otherwise */
    failure: boolean;
}
/**
 * A class representing a successful result
 */
export declare class SuccessResult<T = unknown> implements ResultType<T, undefined> {
    private _res;
    constructor(data: T);
    get result(): T;
    get error(): undefined;
    /** Returns a tuple with `[successValue, undefined]` */
    unwrap(): [T, undefined];
    /** Always returns `true` */
    get success(): true;
    /** Always returns `false` */
    get failure(): false;
}
/**
 * A class representing an error result
 */
export declare class FailureResult<E = Error> implements ResultType<undefined, E> {
    private _res;
    constructor(error: E);
    get result(): undefined;
    get error(): E;
    /** Returns a tuple with `[undefined, failureValue]` */
    unwrap(): [undefined, E];
    /** Always returns `false` */
    get success(): false;
    /** Always returns `true` */
    get failure(): true;
}
/**
 * Class representing a result that can both have successful and failed
 * values. This is only used internally by and returned from [[allSettled]]
 */
export declare class SuccessAndFailureResult<T, E = Error> implements ResultType<T, E> {
    private _res;
    private _err;
    constructor(res: T, err: E);
    get result(): T;
    get error(): E;
    unwrap(): [T, E];
    get success(): boolean;
    get failure(): boolean;
}
/**
 * Utility function for creating a [[SuccessResult]] instance
 * @param result
 */
export declare function success<T>(result: T): SuccessResult<T>;
/**
 * Utility function for creating a [[FailureResult]] instance
 * @param error
 */
export declare function failure<E = Error>(error: E): FailureResult<E>;
//# sourceMappingURL=result.d.ts.map