interface BaseResult<T, E> {
    map<N>(fn: (data: T) => N): Result<N, E>;
    mapErr<N>(fn: (data: E) => N): Result<T, N>;
    isOk(): this is ResultOk<T>;
    isErr(): this is ResultErr<E>;
    unwrap(): T;
}
export declare class UnwrapError<E> extends Error {
    readonly data: E;
    constructor(data: E);
}
export type Result<T, E> = ResultOk<T> | ResultErr<E>;
export type ResultPromise<T, E> = Promise<Result<T, E>>;
export declare class R {
    static map<T, E, NT>(transform: (data: T) => Result<NT, E> | Promise<Result<NT, E>>): (result: Result<T, E>) => Promise<Result<NT, E>>;
    static map<T, E, N>(transform: (data: T) => N | Promise<N>): (result: Result<T, E>) => Promise<Result<N, E>>;
    static mapErr<T, E, NT, NE>(transform: (data: E) => Result<NT, NE> | Promise<Result<NT, NE>>): (result: Result<T, E>) => Promise<Result<NT, NE>>;
    static mapErr<T, E, N>(transform: (data: E) => N | Promise<N>): (result: Result<T, E>) => Promise<Result<T, N>>;
    static flatMap<T, E>(results: Result<T, E>[]): Result<T[], E>;
}
export declare class ResultOk<T> implements BaseResult<T, never> {
    readonly data: T;
    constructor(data: T);
    map<N>(transform: (data: T) => N): Result<N, never>;
    mapErr<N>(): Result<T, N>;
    isOk(): this is ResultOk<T>;
    isErr(): this is ResultErr<never>;
    unwrap(): T;
}
export declare class ResultErr<E> implements BaseResult<never, E> {
    readonly data: E;
    constructor(data: E);
    map<N>(): Result<N, E>;
    mapErr<N>(fn: (data: E) => N): Result<never, N>;
    isOk(): this is ResultOk<never>;
    isErr(): this is ResultErr<E>;
    unwrap(): never;
}
export declare function Ok<T>(data: T): Result<T, never>;
export declare function Err<E>(data: E): Result<never, E>;
export declare function wrapOk<T, E>(data: T | Result<T, E>): Result<T, E>;
export declare function wrapErr<T, E>(data: E | Result<T, E>): Result<T, E>;
export {};