import { Monad } from '../control/monad';
import { Alt } from '../control/alt';
import { Plus } from '../control/plus';
import { Alternative } from '../control/alternative';
import { Extend } from '../control/extend';
import { Eq } from './eq';
/**
 * Maybe monad represents an optional or nullable value.
 */
export declare abstract class Maybe<A> implements Monad<A>, Alt<A>, Plus<A>, Alternative<A>, Extend<A>, Eq<Maybe<A>> {
    static of<A>(value: A): Maybe<A>;
    static just<A>(value: A): Maybe<A>;
    static nothing<A>(): Maybe<A>;
    /**
     * fromNullable constructs a Maybe from a value that may be null.
     */
    static fromNullable: <A_1>(a: A_1 | undefined | null) => Maybe<A_1>;
    /**
     * fromArray checks an array to see if it's empty
     *
     * Returns [[Nothing]] if it is, [[Just]] otherwise.
     */
    static fromArray: <A_1>(a: A_1[]) => Maybe<A_1[]>;
    /**
     * fromObject uses Object.keys to turn see if an object
     * has any own properties.
     */
    static fromObject: <A_1 extends Object>(o: A_1) => Maybe<A_1>;
    /**
     * fromString constructs Nothing<A> if the string is empty or Just<A> otherwise.
     */
    static fromString: (s: string) => Maybe<string>;
    /**
     * fromBoolean constructs Nothing if b is false, Just<A> otherwise
     */
    static fromBoolean: (b: boolean) => Maybe<boolean>;
    /**
     * fromNumber constructs Nothing if n is 0 Just<A> otherwise.
     */
    static fromNumber: (n: number) => Maybe<number>;
    abstract of(a: A): Maybe<A>;
    abstract map<B>(_: (a: A) => B): Maybe<B>;
    abstract ap<B>(_: Maybe<(a: A) => B>): Maybe<B>;
    abstract chain<B>(_: (a: A) => Maybe<B>): Maybe<B>;
    abstract alt(a: Maybe<A>): Maybe<A>;
    abstract eq(e: Maybe<A>): boolean;
    abstract extend<B>(_: (ex: Maybe<A>) => B): Maybe<B>;
    /**
     * orJust is like applying map to the Nothing<A> side.
     */
    abstract orJust<B>(_f: () => B): Maybe<A | B>;
    /**
     * orElse allows for an alternative Maybe value to
     * be provided when Nothing<A> but using a function.
     */
    abstract orElse<B>(f: () => Maybe<B>): Maybe<A | B>;
    /**
     * isNothing tests whether the Maybe is a Nothing.
     */
    abstract isNothing(): boolean;
    /**
     * isJust tests whether the Maybe is a Just.
     */
    abstract isJust(): boolean;
    /**
     * get the value from a Maybe.
     */
    abstract get(): A;
    empty(): Maybe<A>;
}
/**
 * Nothing represents the absence of a usable value.
 */
export declare class Nothing<A> extends Maybe<A> {
    map<B>(_: (a: A) => B): Maybe<B>;
    ap<B>(_: Maybe<(a: A) => B>): Maybe<B>;
    of(a: A): Maybe<A>;
    chain<B>(_: (a: A) => Maybe<B>): Maybe<B>;
    alt(a: Maybe<A>): Maybe<A>;
    extend<B>(_: (ex: Maybe<A>) => B): Maybe<B>;
    eq(m: Maybe<A>): m is Nothing<any>;
    orJust<B>(f: () => B): Maybe<B>;
    orElse<B>(f: () => Maybe<B>): Maybe<B>;
    isNothing(): boolean;
    isJust(): boolean;
    get(): A;
}
/**
 * Just represents the presence of a usable value.
 */
export declare class Just<A> extends Maybe<A> {
    value: A;
    constructor(value: A);
    map<B>(f: (a: A) => B): Maybe<B>;
    ap<B>(mb: Maybe<(a: A) => B>): Maybe<B>;
    of(a: A): Maybe<A>;
    chain<B>(f: (a: A) => Maybe<B>): Maybe<B>;
    alt(_: Maybe<A>): Maybe<A>;
    extend<B>(f: (ex: Maybe<A>) => B): Maybe<B>;
    eq(m: Maybe<A>): boolean;
    orJust<B>(_: (a: A) => B): Maybe<A>;
    orElse<B>(_: (a: A) => B): Maybe<A>;
    isNothing(): boolean;
    isJust(): boolean;
    get(): A;
}
export declare const nothing: typeof Maybe.nothing;
export declare const just: typeof Maybe.just;
export declare const fromNullable: <A>(a: A | undefined | null) => Maybe<A>;
export declare const fromArray: <A>(a: A[]) => Maybe<A[]>;
export declare const fromObject: <A extends Object>(o: A) => Maybe<A>;
export declare const fromString: (s: string) => Maybe<string>;
export declare const fromBoolean: (b: boolean) => Maybe<boolean>;
export declare const fromNumber: (n: number) => Maybe<number>;
export declare const fromNaN: (n: number) => Maybe<number>;