import { ErrFrom, OkFrom, Option, OptionPromise, Result, ResultLike, ResultMapOption, ResultMapOrElse, ResultMapResult, ResultPromise, ResultPromiseLike, ResultPromiseMapOption, ResultPromiseMapOrElse, ResultPromiseMapResult, UnwrapableResult } from "./mod";
/**
 * Test that a variable implements the {@linkcode Option<T>} interface
 * @returns true if variable can be cast to `Option<T>`
 */
export declare function isResult<T = unknown, E = unknown>(possibleResult: unknown): possibleResult is Result<T, E>;
export declare function isResultPromise<T = unknown, E = unknown>(possibleResult: unknown): possibleResult is ResultPromise<T, E>;
export declare function isResultLike<T = unknown, E = unknown>(possibleResult: unknown): possibleResult is ResultLike<T, E>;
/**
 * Creates a `Result<T,E>` with an `Ok` value of type T.
 *
 * When the value is {@linkcode ResultLike}, the actual return value is that.
 * When the value is a Promise to T, the return value implements {@linkcode ResultPromise<T,E>}
 */
export declare function Ok<T, E>(ok: T): OkFrom<T, E>;
/**
 * Create an {@linkcode ResultPromise} from a value.
 * @example
 * ```typescript
 * declare function calculate(n: number): ResultPromise<number,string>;
 *
 * Ok(42)
 *   .mapResult(
 *     // when using Ok here, the compiler will error on calculate with an Argument Error
 *     () => OkPromise<number,string>(-1),
 *     calculate
 *   );
 * ```
 */
export declare function OkPromise<T, E>(value: T): ResultPromise<T, E>;
/**
 * Creates a `Result<T,E>` with an `Err` value of type E.
 *
 * When the value is {@linkcode ResultLike}, the actual return value is that.
 * When the value is a Promise to E, the return value implements {@linkcode ResultPromise<T,E>}
 */
export declare function Err<T, E>(err: E): ErrFrom<T, E>;
/**
 * Create an {@linkcode ResultPromise} from a value.
 * @example
 * ```typescript
 * declare function calculate(n: number): ResultPromise<number,string>;
 *
 * Ok(42)
 *   .mapResult(
 *     // when using Err here, the compiler will error on calculate with an Argument Error
 *     () => ErrPromise<number,string>("could not calculate"),
 *     calculate
 *   );
 * ```
 */
export declare function ErrPromise<T, E>(err: E): ResultPromise<T, E>;
export declare class ResultValue<T, E> implements Result<T, E>, UnwrapableResult<T, E> {
    result: UnwrapableResult<T, E>;
    constructor(result: UnwrapableResult<T, E>);
    get type(): symbol;
    static from<T, E>(result: UnwrapableResult<T, E>): Result<T, E>;
    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;
    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, fn: (value: T) => U): ResultMapResult<U>;
    mapOption<U>(def: (err: E) => U, fn: (value: T) => U): ResultMapOption<U>;
    mapOrElse<U>(def: (err: E) => U, fn: (value: T) => U): ResultMapOrElse<U>;
    ok(): Option<T>;
    or(optb: 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(def: T): T;
    unwrapOrElse(def: (err: E) => T): T;
    unwrapOrElse(def: (err: E) => Promise<T>): T | Promise<T>;
    [Symbol.iterator](): IterableIterator<T>;
}
type Creator<T, E> = ((v: T) => OkFrom<T, E>) | ((e: E) => OkFrom<T, E>);
export declare class PromisedResult<T, E> implements ResultPromise<T, E> {
    private promise;
    constructor(promise: Promise<Result<T, E>>, creator: Creator<T, E>);
    get [Symbol.toStringTag](): string;
    static from<U, F>(promise: Promise<Result<U, F>>, then?: Creator<U, F>): ResultPromise<U, F>;
    then<TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): Promise<Result<T, E> | TResult>;
    finally(onfinally?: (() => void) | null | undefined): Promise<Result<T, E>>;
    and<U>(res: Result<U, E>): ResultPromise<U, E>;
    andThen<U>(fn: (value: T) => ResultLike<U, E>): ResultPromise<U, E>;
    err(): OptionPromise<E>;
    isOk(): Promise<boolean>;
    isErr(): Promise<boolean>;
    map<U>(fn: (value: T) => Promise<U>): ResultPromise<U, E>;
    map<U>(fn: (value: T) => U): ResultPromise<U, E>;
    mapErr<F>(fn: (err: E) => Promise<F>): ResultPromise<T, F>;
    mapErr<F>(fn: (err: E) => F): ResultPromise<T, F>;
    mapResult<U>(def: (err: E) => U, fn: (value: T) => U): ResultPromiseMapResult<U>;
    mapOption<U>(def: (err: E) => U, fn: (value: T) => U): ResultPromiseMapOption<U>;
    mapOrElse<U>(def: (err: E) => U, fn: (value: T) => U): ResultPromiseMapOrElse<U>;
    ok(): OptionPromise<T>;
    or(optb: Result<T, E>): ResultPromise<T, E>;
    orElse(fn: (err: E) => Promise<Result<T, E>>): ResultPromise<T, E>;
    orElse(fn: (err: E) => Result<T, E>): ResultPromise<T, E>;
    unwrapOr(def: T): Promise<T>;
    unwrapOrElse(def: (err: E) => T): Promise<T>;
    unwrapOrElse(def: (err: E) => Promise<T>): Promise<T>;
}
export {};