export interface Functor<T> {
    map<B>(fn: (arg: T) => B): Maybe<B>;
}
export interface Applicative<T> extends Functor<T> {
    ap<A>(fn: Applicative<(arg: T) => A>): Applicative<A>;
}
export interface Monad<T> extends Applicative<T> {
    bind<A>(fn: (arg: T) => Monad<A>): Monad<A>;
}
export declare class Maybe<T> implements Monad<T> {
    private value?;
    constructor(value?: T | undefined);
    static just<A>(val: A): Maybe<A>;
    static nothing<A>(): Maybe<A>;
    static maybe<A>(val: A | null | undefined): Maybe<A>;
    static of: typeof Maybe.maybe;
    static join<A>(nestedMaybe: Maybe<Maybe<A>>): Maybe<A>;
    static sequence(arr: Maybe<any>[]): Maybe<any[]>;
    static traverse<A, B>(fn: (input: A) => B, arr: Maybe<A>[]): Maybe<B[]>;
    static justMap<A, B>(fn: (input: A) => Maybe<B>, arr: A[]): B[];
    static filterSomethings<A>(arr: Array<Maybe<A>>): A[];
    static lift<A, B>(fn: (input: A) => B): (mX: Maybe<A>) => Maybe<B>;
    static lift2<A, B, C>(fn: (x: A, y: B) => C): (mX: Maybe<A>, mY: Maybe<B>) => Maybe<C>;
    static lift3<A, B, C, D>(fn: (x: A, y: B, z: C) => D): (mA: Maybe<A>, mB: Maybe<B>, mC: Maybe<C>) => Maybe<D>;
    static toPromise<A>(maybe: Maybe<A>): Promise<A>;
    map<U>(fn: (value: T) => U | undefined | null): Maybe<U>;
    asyncMap<U>(fn: (value: T) => Promise<U | undefined | null>): Promise<U>;
    alt(elseValue: Maybe<T>): Maybe<T>;
    altMap(elseFn: () => Maybe<T>): Maybe<T>;
    ap<U>(mFn: Maybe<(value: T) => U>): Maybe<U>;
    bind<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
    withDefault(fallback: T): T;
    withDefaultFn(fallbackFn: () => T): T;
    get hasNothing(): boolean;
    get hasSomething(): boolean;
    unsafeElse(fn: () => void): void;
}