import { Option, PromisedResult, Result, ResultMapOption, ResultMapOrElse, ResultMapResult, ResultPromise, ResultPromiseLike, UnwrapableResult } from "./mod";
export declare class OkValue<T, E> implements UnwrapableResult<T, E> {
    okValue: T;
    constructor(okValue: T);
    static from<T, E>(ok: T): UnwrapableResult<T, E>;
    [Symbol.iterator](): IterableIterator<T>;
    get type(): symbol;
    and<U>(res: Result<U, E>): Result<U, E>;
    andThen<U>(op: (value: T) => ResultPromiseLike<U, E>): ResultPromise<U, E>;
    andThen<U>(op: (value: T) => Result<U, E>): Result<U, E>;
    err(): Option<E>;
    isOk(): boolean;
    isErr(): boolean;
    /**
     * Maps an Result<T,E> to Result<U,E> by applying a function to a contained value.
     */
    map<U>(fn: (value: T) => Promise<U>): PromisedResult<U, E>;
    map<U>(fn: (value: T) => U): Result<U, E>;
    mapErr<F>(fn: (err: E) => Promise<F>): ResultPromise<T, F>;
    mapErr<F>(fn: (err: E) => F): Result<T, F>;
    mapResult<U>(_: (err: E) => U, fn: (ok: T) => U): ResultMapResult<U>;
    mapOption<U>(_: (err: E) => U, fn: (value: T) => U): ResultMapOption<U>;
    mapOrElse<U>(_: (err: E) => U, fn: (value: T) => U): ResultMapOrElse<U>;
    ok(): Option<T>;
    or(_: Result<T, E>): Result<T, E>;
    orElse(fn: (err: E) => Promise<Result<T, E>>): PromisedResult<T, E>;
    orElse(fn: (err: E) => Result<T, E>): Result<T, E>;
    unwrap(): T;
    unwrapOr(_: T): T;
    unwrapOrElse(def: (err: E) => T): T;
    unwrapOrElse(def: (err: E) => Promise<T>): T | Promise<T>;
}
export declare class ErrValue<T, E> implements UnwrapableResult<T, E> {
    private errValue;
    constructor(errValue: E);
    [Symbol.iterator](): IterableIterator<T>;
    static from<T, E>(err: E): Result<T, E>;
    and<U>(_: Result<U, E>): Result<U, E>;
    andThen<U>(fn: (_: T) => ResultPromiseLike<U, E>): PromisedResult<U, E>;
    andThen<U>(fn: (_: T) => Result<U, E>): Result<U, E>;
    err(): Option<E>;
    isOk(): boolean;
    isErr(): boolean;
    map<U>(fn: (value: T) => Promise<U>): PromisedResult<U, E>;
    map<U>(fn: (value: T) => U): Result<U, E>;
    mapErr<F>(fn: (err: E) => Promise<F>): ResultPromise<T, F>;
    mapErr<F>(fn: (err: E) => F): Result<T, F>;
    mapResult<U>(def: (err: E) => U, _: (ok: T) => U): ResultMapResult<U>;
    mapOption<U>(def: (err: E) => U, _: (_: T) => U): ResultMapOption<U>;
    mapOrElse<U>(def: (err: E) => U, _: (_: T) => U): ResultMapOrElse<U>;
    ok(): Option<T>;
    or(optb: Result<T, E>): Result<T, E>;
    orElse(fn: (err: E) => Promise<Result<T, E>>): ResultPromise<T, E>;
    orElse(fn: (err: E) => Result<T, E>): Result<T, E>;
    unwrap(): T;
    unwrapOr(def: T): T;
    unwrapOrElse(def: (err: E) => T): T;
    unwrapOrElse(def: (err: E) => Promise<T>): T | Promise<T>;
    get type(): symbol;
}