import * as t from 'io-ts';
import { Serialisable } from './Serialisable';
export declare type URI = 'Maybe';
export declare class Maybe<A> {
    private readonly value;
    static just: <A_1>(a: A_1) => Maybe<A_1>;
    static nothing: Maybe<never>;
    static fromNullable: <A_1>(a: A_1 | null | undefined) => Maybe<A_1>;
    static tryCatch: <A_1>(f: () => A_1) => Maybe<A_1>;
    private constructor();
    uri: URI;
    map: <B>(f: (a: A) => B) => Maybe<B>;
    flatMap: <B>(f: (a: A) => Maybe<B>) => Maybe<B>;
    mapNullable: <B>(f: (a: A) => B | null | undefined) => Maybe<B>;
    fold: <B>(onNothing: B, onJust: (a: A) => B) => B;
    foldL: <B>(onNothing: () => B, onJust: (a: A) => B) => B;
    getOrElse(a: A): A;
    filter: (p: (a: A) => boolean) => Maybe<A>;
    isNothing: boolean;
    isJust: boolean;
    exists: (p: (a: A) => boolean) => boolean;
    toNullable: A | null;
    foldToNullable: <B>(f: (a: A) => B) => B | null;
}
declare type t<A> = Nothing | Just<A>;
declare type Nothing = {
    tag: 'Nothing';
};
declare type Just<A> = {
    tag: 'Just';
    value: A;
};
export declare type SerialiseableMaybe<A> = Serialisable<URI, t<A>>;
export declare const serialisableMaybeC: <A>(a: t.Type<A, A, unknown>) => t.Type<Serialisable<"Maybe", t<A>>, Serialisable<"Maybe", t<A>>, unknown>;
export declare const fromSerialisable: <A>(a: t.Type<A, A, unknown>) => t.Type<Maybe<A>, Maybe<A>, unknown>;
export declare const JustC: <A>(a: t.Type<A, A, unknown>) => t.Type<Maybe<A>, Maybe<A>, unknown>;
export declare const NothingC: <A>(a: t.Type<A, A, unknown>) => t.Type<Maybe<A>, Maybe<A>, unknown>;
export declare const MaybeC: <A>(a: t.Type<A, A, unknown>) => t.Type<Maybe<A>, Maybe<A>, unknown>;
export declare const requiredC: <A, O>(aC: t.Type<A, O, unknown>, message?: string) => t.Type<A, Maybe<O>, unknown>;
export {};