export declare class Result<A = never, E = never> {
    protected _ok: boolean;
    protected _artifact: A;
    protected _error: E;
    is_ok(): boolean;
    is_err(): boolean;
    isOk(): boolean;
    isErr(): boolean;
    ok(): A;
    unwrap(): A;
    unwrap_err(): E;
    err(): E;
    unwrapErr(): E;
    when<R = A>(handlers: {
        ok: (artifact: A) => R;
        err: (error: E) => R;
    }): R;
    fold<R = A>(handlers: {
        ok: (artifact: A) => R | Promise<R>;
        err: (error: E) => R | Promise<R>;
    }): Promise<R>;
    map<RT = A>(mapper: (artifact: A) => RT): Result<RT, E>;
    mapErr<RE = E>(mapper: (error: E) => RE): Result<A, RE>;
    mapOr<RT = A>(mapper: (artifact: A) => RT, defaultValue: RT): RT;
    mapOrElse<RT = A>(mapper: (artifact: A) => RT, errMapper: (error: E) => RT): RT;
    mapOrErr<RE = E>(mapper: (error: E) => RE, defaultValue: RE): RE;
    mapErrOr<RT = A>(mapper: (error: E) => RT, defaultValue: RT): RT;
    mapErrOrElse<T = A>(mapper: (error: E) => T, defaultValue: T): T;
    unwrapOr(defaultValue: A): A;
    unwrapOrElse(defaultValue: (error: E) => A): A;
    andThen<RT = A>(fn: (artifact: A) => Result<RT, E>): Result<RT, E>;
    orElse<RE = E>(fn: (error: E) => Result<A, RE>): Result<A, RE>;
    expect(message: string): A;
    expectErr(message: string): E;
    tap(fn: (artifact: A) => void): Result<A, E>;
    tapErr(fn: (error: E) => void): Result<A, E>;
}
export declare class Ok<A = never, E = never> extends Result<A, E> {
    constructor(artifact: A);
    map<RT = A>(mapper: (artifact: A) => RT): Ok<RT, E>;
    mapErr<RE = E>(mapper: (error: E) => RE): Ok<A, RE>;
}
export declare class Err<E = never, A = never> extends Result<A, E> {
    constructor(error: E);
    map<RT = A>(mapper: (artifact: A) => RT): Err<E, RT>;
    mapErr<RE = E>(mapper: (error: E) => RE): Err<RE, A>;
}