import Traversable from "../../specifications/Traversable";
import Filterable from "../../specifications/Filterable";
import Monad from "../../specifications/Monad";
import { Applicative, ApplicativeTypeRep } from "../../specifications/Applicative";
import { FNA1 } from "../../specifications/Function";
export default abstract class Maybe<A> implements Monad<A>, Filterable<A>, Traversable<A> {
    protected constructor();
    abstract map<B>(fn: (a: A) => B): Maybe<B>;
    abstract ap<B>(other: Maybe<B>): A extends FNA1<B, infer C> ? Maybe<C> : Maybe<any>;
    abstract chain<B>(fn: (value: A) => Maybe<B>): Maybe<B>;
    static of<A>(value: A): Maybe<A>;
    abstract filter(fn: (value: A) => Boolean): Maybe<A>;
    abstract reduce<B>(reducer: (accumulator: B, value: A) => B, initial: B): B;
    abstract traverse<B>(TypeRep: ApplicativeTypeRep<Maybe<B>>, fn: (a: A) => Applicative<B>): Applicative<Maybe<B>>;
    abstract join(): Maybe<A | any>;
    abstract get(): A | never;
    abstract getOrElse(other: A): A;
    abstract getOrElseRun(fn: () => A): A;
    abstract inspect(): string;
    static just<A>(value: A): Just<A>;
    static nothing<A>(_?: A): Nothing<A>;
    static fromNullable<A>(value?: A): Maybe<A>;
    get isJust(): Boolean;
    get isNothing(): Boolean;
}
declare class Nothing<A> extends Maybe<A> {
    constructor();
    map<B>(fn: (a: A) => B): Nothing<B>;
    ap<B>(other: Maybe<B>): A extends FNA1<B, infer C> ? Nothing<C> : Nothing<any>;
    chain<B>(fn: (value: A) => Maybe<B>): Nothing<B>;
    filter(fn: (value: A) => Boolean): Nothing<A>;
    reduce<B>(reducer: (accumulator: B, value: A) => B, initial: B): B;
    traverse<B>(TypeRep: ApplicativeTypeRep<Maybe<B>>, fn: (a: A) => Applicative<B>): Applicative<Maybe<B>>;
    join(): Nothing<A>;
    get(): never;
    getOrElse(other: A): A;
    getOrElseRun(fn: () => A): A;
    get isNothing(): Boolean;
    inspect(): string;
}
declare class Just<A> extends Maybe<A> {
    protected readonly value: A;
    constructor(value: A);
    map<B>(fn: (a: A) => B): Maybe<B>;
    ap<B>(other: Maybe<B>): A extends FNA1<B, infer C> ? Maybe<C> : Maybe<any>;
    chain<B>(fn: (value: A) => Maybe<B>): Maybe<B>;
    filter(fn: (value: A) => Boolean): Maybe<A>;
    reduce<B>(reducer: (accumulator: B, value: A) => B, initial: B): B;
    traverse<B>(TypeRep: ApplicativeTypeRep<Maybe<B>>, fn: (a: A) => Applicative<B>): Applicative<Maybe<B>>;
    join(): Maybe<A | any>;
    get(): A;
    getOrElse(other: A): A;
    getOrElseRun(fn: () => A): A;
    get isJust(): Boolean;
    inspect(): string;
}
export {};