import { DefaultOrFunc } from "./fn";
import { None, Maybe, Voidable } from "./maybe";
/** Means success */
export interface Ok<T> {
    res: T;
}
/** Means failure */
export interface Err<E> {
    err: E;
}
/** Union of success or failure
 * ```ts
 * type Result<T, E> = Ok<T> | Err<E>
 * ```
*/
export declare type Result<T, E> = Ok<T> | Err<E>;
/** Make a `Ok<T>` */
export declare function ok<T>(res: T): Ok<T>;
/** Make a `Err<E>` */
export declare function err<E>(err: E): Err<E>;
/** Check value is `OK<T>` */
export declare function isOk<T>(v?: any): v is Ok<T>;
/** Check value is `Err<E>` */
export declare function isErr<E>(v?: any): v is Err<E>;
/** Check value is `Result<T, E>` */
export declare function isResult<T, E>(v?: any): v is Result<T, E>;
/** Get `T` in `Ok<T>` */
export declare function getOk<T>(v: Ok<T>): T;
/** Get nothing */
export declare function getOk<E>(v: Err<E>): undefined;
/** Get `T` in `Result<T, E>` */
export declare function getOk<T, E>(v: Result<T, E>): Voidable<T>;
/** Get nothing */
export declare function getOk<T, E>(v?: undefined): undefined;
/** Get nothing */
export declare function getOk<T, E>(v?: null): null;
/** Get nothing */
export declare function getOk<T, E>(v?: None): None;
/** Get `T` in `Result<T, E>` */
export declare function getOk<T, E>(v?: Maybe<Result<T, E>>): Voidable<T>;
/** Get `E` in `Err<E>` */
export declare function getErr<E>(v: Err<E>): E;
/** Get nothing */
export declare function getErr<T>(v: Ok<T>): undefined;
/** Get `E` in `Result<T, E>` */
export declare function getErr<T, E>(v: Result<T, E>): Voidable<E>;
/** Get nothing */
export declare function getErr<T, E>(v?: undefined): undefined;
/** Get nothing */
export declare function getErr<T, E>(v?: null): null;
/** Get nothing */
export declare function getErr<T, E>(v?: None): None;
/** Get `E` in `Result<T, E>` */
export declare function getErr<T, E>(v?: Maybe<Result<T, E>>): Voidable<E>;
export declare function mapOk<T, E, U>(v: Result<T, E>, f: (val: T) => U): Result<U, E>;
export declare function mapErr<T, E, U>(v: Result<T, E>, f: (val: E) => U): Result<T, U>;
export declare namespace Result {
    export function and<T, E, U>(v: Result<T, E>, o: DefaultOrFunc<Result<U, E>>): Result<U, E>;
    export function or<T, E>(v: Result<T, E>, o: DefaultOrFunc<Result<T, E>>): Result<T, E>;
    /** Transpose Result to Maybe */
    export function transpose<T, E>(v: Result<Maybe<T>, E>): Voidable<Result<T, E>>;
    type NestedOk<T> = Ok<T> | Ok<NestedOk<T>>;
    type NestedResult<T, E> = Result<T, E> | Ok<NestedResult<T, E>>;
    type FlattenResult<N> = N extends NestedOk<infer T> ? FlattenResult<T> : N extends Err<any> ? N : Ok<N>;
    /** Flatten result
     *
     * ## Example
     * ```ts
     * let a: Result<1, 2> = flatten<Result<Result<Result<1, 2>, 2>, 2>>(ok(ok(ok(1))))
     * let b: Ok<1> = flatten<Ok<Ok<Ok<1>>>>(ok(ok(ok(1))))
     * let c: Err<2> = flatten<Ok<Ok<Err<2>>>>(ok(ok(err(2))))
     * ```
     */
    export function flatten<N extends NestedResult<any, any>>(v: N): FlattenResult<N>;
    export {};
}