import { default as Alt } from '../../interface/Alt';
import { default as Monad } from '../../interface/Monad';
import { default as PatternMatch } from '../../interface/Patternmatch';
import { default as Setoid } from '../../interface/Setoid';
import { default as Either } from './../Either';
export default abstract class Maybe<A> implements Setoid, Monad<A>, Alt<A>, PatternMatch {
    protected _value: A;
    static of<B>(v: B): Maybe<B>;
    static zero<B>(): Maybe<B>;
    static Just<B>(v: B): Maybe<B>;
    static Nothing<B>(): Maybe<B>;
    static fromNullable<B>(v: any): Maybe<B>;
    static withDefault<B>(def: any, v: any): Maybe<B>;
    static catMaybes<B>(ar: Array<Maybe<B>>): Array<any>;
    static isNothing<B>(v: Maybe<B>): boolean;
    static isJust<B>(v: Maybe<B>): boolean;
    of<A>(v: A): Maybe<A>;
    alt<B>(v: Maybe<B>): Maybe<B>;
    ap<B, C>(j: Maybe<B>): Maybe<C>;
    getValue(): A;
    abstract equals(n: Setoid): boolean;
    abstract map<B>(f: (a: A) => B): Maybe<B>;
    abstract chain<B>(f: (a: A) => Maybe<B>): Maybe<B>;
    abstract caseOf<T>(o: {
        Nothing: () => T;
        Just: (a: A) => T;
    }): T;
    abstract isNothing(): boolean;
    abstract isJust(): boolean;
}
export declare class Nothing<A> extends Maybe<A> {
    equals(n: Setoid): boolean;
    map<B>(f: (a: A) => B): Maybe<B>;
    chain<B>(f: (a: A) => Maybe<B>): Maybe<B>;
    isJust(): boolean;
    isNothing(): boolean;
    toString(): string;
    caseOf<B>(o: {
        Nothing: () => B;
        Just: (a: A) => B;
    }): B;
}
export declare class Just<A> extends Maybe<A> {
    constructor(v: any);
    equals(j: Setoid): boolean;
    map<B>(f: (a: A) => B): Maybe<B>;
    chain<B>(f: (a: A) => Maybe<B>): Maybe<B>;
    isJust(): boolean;
    isNothing(): boolean;
    toString(): string;
    caseOf<B>(o: {
        Just: (a: A) => B;
        Nothing: () => B;
    }): B;
}
export declare const eitherToMaybe: <A, B>(e: Either<A, B>) => any;
export declare const prop: Function;
export declare const pick: Function;