import { WhenNever, Cata } from '../Basics';
import Either from '../Either';
export interface Maybe<T> {
    isNothing(): boolean;
    isJust(): boolean;
    isEqual<T_>(another: Maybe<WhenNever<T, T_>>): boolean;
    map<R>(fn: (value: T) => R): Maybe<R>;
    chain<R>(fn: (value: T) => Maybe<R>): Maybe<R>;
    filter<T_>(fn: (value: WhenNever<T, T_>) => boolean): Maybe<WhenNever<T, T_>>;
    orElse<T_>(fn: () => Maybe<WhenNever<T, T_>>): Maybe<WhenNever<T, T_>>;
    getOrElse<T_>(defaults: WhenNever<T, T_>): WhenNever<T, T_>;
    fold<R>(onNothing: () => R, onJust: (value: T) => R): R;
    cata<R>(pattern: Pattern<T, R>): R;
    toEither<E>(error: E): Either<E, T>;
    tap<R>(fn: (that: Maybe<T>) => R): R;
}
export declare namespace Maybe {
    type Pattern<T, R> = Cata<{
        Nothing(): R;
        Just(value: T): R;
    }>;
    const Nothing: Maybe<never>;
    const Just: <T>(value: T) => Maybe<T>;
    const fromNullable: <T>(value: T | null | undefined) => Maybe<T extends null | undefined ? never : T>;
    const fromEither: <E, T>(either: Either<E, T>) => Maybe<T>;
    const join: <T>(maybe: Maybe<Maybe<T>>) => Maybe<T>;
    const shape: <O extends {}>(object: { [K in keyof O]: Maybe<O[K]>; }) => Maybe<O>;
    const combine: <T>(array: Maybe<T>[]) => Maybe<(unknown extends T ? never : T)[]>;
    const values: <T>(array: Maybe<T>[]) => (unknown extends T ? never : T)[];
}
export declare type Pattern<T, R> = Maybe.Pattern<T, R>;
export declare const Nothing: Maybe<never>;
export declare const Just: <T>(value: T) => Maybe<T>;
export declare const fromNullable: <T>(value: T | null | undefined) => Maybe<T extends null | undefined ? never : T>;
export declare const fromEither: <E, T>(either: Either<E, T>) => Maybe<T>;
export declare const join: <T>(maybe: Maybe<Maybe<T>>) => Maybe<T>;
export declare const shape: <O extends {}>(object: { [K in keyof O]: Maybe<O[K]>; }) => Maybe<O>;
export declare const combine: <T>(array: Maybe<T>[]) => Maybe<(unknown extends T ? never : T)[]>;
export declare const values: <T>(array: Maybe<T>[]) => (unknown extends T ? never : T)[];
export default Maybe;