/** @module maybe.ts */
import { HKT, Type, URIS } from 'fp-ts/lib/HKT';
import { Applicative, Apply, ArrayApplicative, ArrayApply, HKT0 } from './helper-types';
declare global {
    interface Array<T> {
        _URI: 'Array';
        _A: T;
    }
}
declare module 'fp-ts/lib/HKT' {
    interface URI2HKT<A> {
        Array: A[];
    }
}
declare module 'fp-ts/lib/HKT' {
    interface URI2HKT<A> {
        'babakness/maybe': Maybe<A>;
    }
}
export declare type Maybe<A> = Nothing<A> | Just<A>;
export declare const Maybe: {
    _URI: string;
    of: <A>(a: A) => Maybe<A>;
    /**
     * Place nullable values (undefined and null) into a nothing, otherwise into a Just
     */
    from: <A>(a: A | null | undefined) => Maybe<A>;
};
export declare class Nothing<A> {
    static readonly _URI: 'babakness/maybe';
    static value: Maybe<never>;
    static of(value: any): Maybe<never>;
    readonly _A: A;
    readonly _URI: 'babakness/maybe';
    private constructor();
    fold<B>(valueWhenNothing: B, doWhenJust: (a: A) => B): B;
    reduce<B>(doWhenJust: (a: A) => B, valueWhenNothing: B): B;
    joinOrValue(a: A): A;
    joinOrDo(fn: () => A): A;
    map<B>(fn: (a: A) => B): Maybe<B>;
    mapNullable<B>(fn: (a: A) => B | undefined | null): Maybe<B>;
    chain<B>(fn: (a: A) => Maybe<B>): Maybe<B>;
    isJust(): this is Just<A>;
    isNothing(): this is Nothing<A>;
    /**
     * A shortcut for Maybe1.ap( Maybe2.map( toTuple ) )
     * with better type intelligence
     */
    apTuple<B>(fb: Maybe<B>): Maybe<[B, A]>;
    ap<B>(fab: Maybe<(a: A) => B>): Maybe<B>;
    ap_<B, C>(this: Maybe<(b: B) => C>, fb: Maybe<B>): Maybe<C>;
    sequence<F extends URIS, G extends URIS, B, C>(this: Maybe<HKT<F, B>> & (Maybe<Apply<B>> | Maybe<ArrayApply<B>>), F: HKT0<F> | {
        of: (a: A) => (HKT<G, C> & Apply<any>) | (HKT<G, C> & ArrayApply<any>);
    }): Type<G, Maybe<B>>;
    sequenceNullable<F extends URIS, G extends URIS, B, C>(this: Maybe<HKT<F, B>> & (Maybe<Apply<B>> | Maybe<ArrayApply<B>>), F: HKT0<F> | {
        of: (a: A) => (HKT<G, C> & Apply<any>) | (HKT<G, C> & ArrayApply<any>);
    }): Type<G, Maybe<B>>;
    traverse<F extends URIS, E extends URIS, B, C>(this: Maybe<A>, F: Applicative<C> | ArrayApplicative<E, C>, fn: (a: A) => (HKT<F, B> & Apply<C>) | (HKT<F, B> & ArrayApply<C>)): Type<F, Maybe<B>>;
    traverseNullable<F extends URIS, E extends URIS, B, C>(this: Maybe<A>, F: Applicative<C> | ArrayApplicative<E, C>, fn: (a: A) => (HKT<F, B> & Apply<C>) | (HKT<F, B> & ArrayApply<C>)): Type<F, Maybe<B>>;
}
export declare const nothing: Maybe<never>;
export declare class Just<A> {
    readonly value: A;
    static readonly _URI: 'babakness/maybe';
    static of<T>(value: T): Just<T>;
    readonly _A: A;
    readonly _URI: 'babakness/maybe';
    constructor(value: A);
    traverse<F extends URIS, E extends URIS, B, C>(this: Maybe<A>, F: Applicative<C> | ArrayApplicative<E, C>, fn: (a: A) => (HKT<F, B> & Apply<any>) | (HKT<F, B> & ArrayApply<any>)): Type<F, Maybe<B>>;
    traverseNullable<F extends URIS, E extends URIS, B, C>(this: Maybe<A>, F: Applicative<C> | ArrayApplicative<E, C>, fn: (a: A) => (HKT<F, B> & Apply<any>) | (HKT<F, B> & ArrayApply<any>)): Type<F, Maybe<B>>;
    sequence<F extends URIS, G extends URIS, B, C>(this: Maybe<HKT<F, B>> & (Maybe<Apply<B>> | Maybe<ArrayApply<B>>), F: HKT0<F> | {
        of: (a: A) => (HKT<G, C> & Apply<any>) | (HKT<G, C> & ArrayApply<any>);
    }): Type<G, Maybe<B>>;
    sequenceNullable<F extends URIS, G extends URIS, B, C>(this: Maybe<HKT<F, B>> & (Maybe<Apply<B>> | Maybe<ArrayApply<B>>), F: HKT0<F> | {
        of: (a: A) => (HKT<G, C> & Apply<any>) | (HKT<G, C> & ArrayApply<any>);
    }): Type<G, Maybe<B>>;
    joinOrValue(a: A): A;
    joinOrDo(fn: () => A): A;
    map<B>(fn: (a: A) => B): Maybe<B>;
    mapNullable<B>(fn: (a: A) => B | undefined | null): Maybe<B>;
    chain<B>(fn: (a: A) => Maybe<B>): Maybe<B>;
    /**
     * A shortcut for Maybe1.ap( Maybe2.map( toTuple ) )
     * with better type intelligence
     */
    apTuple<B>(fb: Maybe<B>): Maybe<[B, A]>;
    ap<B>(fab: Maybe<(a: A) => B>): Maybe<B>;
    ap_<B, C>(this: Maybe<(b: B) => C>, fb: Maybe<B>): Maybe<C>;
    fold<B>(valueWhenNothing: B, doWhenJust: (a: A) => B): B;
    reduce<B>(doWhenJust: (a: A) => B, valueWhenNothing: B): B;
    isJust(): this is Just<A>;
    isNothing(): this is Nothing<A>;
}