import { Either } from './Either';
import { Show } from '../typeclasses/Show';
import { Setoid } from '../typeclasses/Setoid';
import { Ord } from '../typeclasses/Ord';
import { Semigroup } from '../typeclasses/Semigroup';
import { Monoid } from '../typeclasses/Monoid';
import { Functor } from '../typeclasses/Functor';
import { Apply } from '../typeclasses/Apply';
import { Applicative } from '../typeclasses/Applicative';
import { Plus } from '../typeclasses/Plus';
import { Alt } from '../typeclasses/Alt';
import { Alternative } from '../typeclasses/Alternative';
import { Chain } from '../typeclasses/Chain';
import { Monad } from '../typeclasses/Monad';
import { Foldable } from '../typeclasses/Foldable';
import { Extend } from '../typeclasses/Extend';
import { Unsafe } from '../typeclasses/Unsafe';
export declare type MaybePatterns<T, U> = {
    Just: (value: T) => U;
    Nothing: () => U;
};
export declare class Maybe<T> implements Show, Setoid<Maybe<T>>, Ord<Maybe<T>>, Semigroup<Maybe<T>>, Monoid<Maybe<T>>, Functor<T>, Apply<T>, Applicative<T>, Alt<T>, Plus<T>, Alternative<T>, Chain<T>, Monad<T>, Foldable<T>, Extend<T>, Unsafe {
    readonly value: T;
    constructor(value: T);
    readonly of: typeof Maybe.of;
    readonly zero: typeof Maybe.zero;
    readonly empty: typeof Maybe.empty;
    readonly 'fantasy-land/alt': (other: Maybe<T>) => Maybe<T>;
    readonly 'fantasy-land/of': typeof Maybe.of;
    readonly 'fantasy-land/ap': <U>(maybeF: Maybe<(value: T) => U>) => Maybe<U>;
    readonly 'fantasy-land/chain': <U>(f: (value: T) => Maybe<U>) => Maybe<U>;
    readonly 'fantasy-land/reduce': <U>(reducer: (accumulator: U, value: T) => U, initialValue: U) => U;
    readonly 'fantasy-land/map': <U>(f: (value: T) => U) => Maybe<U>;
    readonly 'fantasy-land/lte': (other: Maybe<T>) => boolean;
    readonly 'fantasy-land/zero': typeof Maybe.zero;
    readonly 'fantasy-land/extend': <U>(f: (value: Maybe<T>) => U) => Maybe<U>;
    readonly 'fantasy-land/concat': (other: Maybe<T>) => Maybe<T>;
    readonly 'fantasy-land/empty': typeof Maybe.empty;
    readonly 'fantasy-land/equals': (other: Maybe<T>) => boolean;
    static of<T>(value: T): Maybe<T>;
    static fromNullable<T>(value: T | undefined | null | void): Maybe<T>;
    static fromFalsy<T>(value: T | undefined | null | void): Maybe<T>;
    static empty(): typeof Nothing;
    static zero(): typeof Nothing;
    static catMaybes<T>(list: Maybe<T>[]): T[];
    static mapMaybe<T, U>(f: (value: T) => Maybe<U>): (list: T[]) => U[];
    static mapMaybe<T, U>(f: (value: T) => Maybe<U>, list: T[]): U[];
    static encase<T>(throwsF: () => T): Maybe<T>;
    isJust(): boolean;
    isNothing(): this is typeof Nothing;
    inspect(): string;
    toString(): string;
    toJSON(): T;
    equals(other: Maybe<T>): boolean;
    lte(other: Maybe<T>): boolean;
    concat(other: Maybe<T>): Maybe<T>;
    map<U>(f: (value: T) => U): Maybe<U>;
    ap<U>(maybeF: Maybe<(value: T) => U>): Maybe<U>;
    alt(other: Maybe<T>): Maybe<T>;
    chain<U>(f: (value: T) => Maybe<U>): Maybe<U>;
    reduce<U>(reducer: (accumulator: U, value: T) => U, initialValue: U): U;
    extend<U>(f: (value: Maybe<T>) => U): Maybe<U>;
    unsafeCoerce(): T;
    caseOf<U>(patterns: MaybePatterns<T, U>): U;
    orDefault(defaultValue: T): T;
    toList(): T[];
    mapOrDefault<U>(f: (value: T) => U, defaultValue: U): U;
    extract(): T | null;
    toEither<L>(left: L): Either<L, T>;
    ifJust(effect: (value: T) => any): this;
    ifNothing(effect: () => any): this;
    filter(pred: (value: T) => boolean): Maybe<T>;
}
export declare const Just: <T>(value: T) => Maybe<T>;
export declare const Nothing: Maybe<never>;