import { WhenNever } from '../Basics';
import Either from '../Either';
import { Maybe as IMaybe, Pattern } from './index';
declare abstract class Maybe<T> implements IMaybe<T> {
    isNothing(): boolean;
    isJust(): boolean;
    abstract isEqual<T_>(_another: IMaybe<WhenNever<T, T_>>): boolean;
    map<R>(_fn: (value: T) => R): IMaybe<R>;
    chain<R>(_fn: (value: T) => IMaybe<R>): IMaybe<R>;
    filter<T_>(_fn: (value: WhenNever<T, T_>) => boolean): IMaybe<WhenNever<T, T_>>;
    orElse<T_>(fn: () => IMaybe<WhenNever<T, T_>>): IMaybe<WhenNever<T, T_>>;
    getOrElse<T_>(defaults: WhenNever<T, T_>): WhenNever<T, T_>;
    abstract fold<R>(onNothing: () => R, onJust: (value: T) => R): R;
    abstract cata<R>(pattern: Pattern<T, R>): R;
    toEither<E>(error: E): Either<E, T>;
    tap<R>(fn: (that: IMaybe<T>) => R): R;
}
export declare const Nothing: IMaybe<never>;
export declare class Just<T> extends Maybe<T> {
    private readonly value;
    constructor(value: T);
    isJust(): boolean;
    isEqual<T_>(another: IMaybe<WhenNever<T, T_>>): boolean;
    map<R>(fn: (value: T) => R): IMaybe<R>;
    chain<R>(fn: (value: T) => IMaybe<R>): IMaybe<R>;
    filter<T_>(fn: (value: WhenNever<T, T_>) => boolean): IMaybe<WhenNever<T, T_>>;
    orElse<T_>(): IMaybe<WhenNever<T, T_>>;
    getOrElse<T_>(): WhenNever<T, T_>;
    fold<R>(_onNothing: () => R, onJust: (value: T) => R): R;
    cata<R>(pattern: Pattern<T, R>): R;
    toEither(): Either<never, T>;
}
export {};