import * as t from 'io-ts';
import { Maybe } from './Maybe';
import { Serialisable } from './Serialisable';
export declare type URI = 'Result';
export declare class Result<E, A> {
    private readonly value;
    static ok: <E_1, A_1>(value: A_1) => Result<E_1, A_1>;
    static error: <E_1, A_1>(error: E_1) => Result<E_1, A_1>;
    static fromMaybe: <E_1, A_1>(e: E_1, ma: Maybe<A_1>) => Result<E_1, A_1>;
    static fromPredicate: <E_1, A_1>(fallback: E_1, p: (a: A_1) => boolean) => (a: A_1) => Result<E_1, A_1>;
    private constructor();
    uri: URI;
    fold: <B>(onError: (e: E) => B, onOk: (a: A) => B) => B;
    getOk: () => Maybe<A>;
    getOrElse: (a: A) => A;
    getOrElseBy: (a: (e: E) => A) => A;
    getError: () => Maybe<E>;
    getErrorOrElse: (e: E) => E;
    getErrorOrElseBy: (e: (a: A) => E) => E;
    isError: boolean;
    isOk: boolean;
    flip: () => Result<A, E>;
    map: <B>(f: (a: A) => B) => Result<E, B>;
    mapError: <F>(f: (e: E) => F) => Result<F, A>;
    flatMap: <B>(f: (a: A) => Result<E, B>) => Result<E, B>;
    catchError: <F>(f: (e: E) => Result<F, A>) => Result<F, A>;
}
declare type t<E, A> = {
    tag: 'Error';
    error: E;
} | {
    tag: 'Ok';
    value: A;
};
export declare type SerialiseableResult<E, A> = Serialisable<URI, t<E, A>>;
export declare const serialisableResultC: <E, A>(e: t.Type<E, E, unknown>, a: t.Type<A, A, unknown>) => t.Type<Serialisable<"Result", t<E, A>>, Serialisable<"Result", t<E, A>>, unknown>;
export {};