import { $type, Eval, HKT, Kind, Lazy, TyK, TyVar } from '@fp4ts/core';
import { Eq, Monoid } from '@fp4ts/cats-kernel';
import { Alternative } from '../alternative';
import { Applicative } from '../applicative';
import { CoflatMap } from '../coflat-map';
import { EqK } from '../eq-k';
import { Functor } from '../functor';
import { FunctorFilter } from '../functor-filter';
import { Monad } from '../monad';
import { MonoidK } from '../monoid-k';
import { TraversableFilter } from '../traversable-filter';
import { Either } from './either';
import { List } from './collections';
export type Option<A> = _Option<A>;
export declare const Option: OptionObj;
declare abstract class _Option<out A> {
    private readonly __void;
    private readonly _A;
    get isEmpty(): boolean;
    get nonEmpty(): boolean;
    abstract readonly get: A;
    get toList(): List<A>;
    get toArray(): A[];
    toLeft<B>(right: Lazy<B>): Either<A, B>;
    toRight<B>(left: Lazy<B>): Either<B, A>;
    fold<B1, B2 = B1>(onNone: () => B1, onSome: (a: A) => B2): B1 | B2;
    map<B>(f: (a: A) => B): Option<B>;
    tap(f: (a: A) => unknown): Option<A>;
    map2<B, C>(that: Option<B>, f: (a: A, b: B) => C): Option<C>;
    map2Eval<B, C>(that: Eval<Option<B>>, f: (a: A, b: B) => C): Eval<Option<C>>;
    filter<B extends A>(f: (a: A) => a is B): Option<B>;
    filter(f: (a: A) => boolean): Option<A>;
    filterNot(p: (a: A) => boolean): Option<A>;
    collect<B>(f: (a: A) => Option<B>): Option<B>;
    orElse<A>(this: Option<A>, that: Lazy<Option<A>>): Option<A>;
    '<|>'<A>(this: Option<A>, that: Lazy<Option<A>>): Option<A>;
    orElseEval<A>(this: Option<A>, that: Eval<Option<A>>): Eval<Option<A>>;
    getOrElse<A>(this: Option<A>, defaultValue: Lazy<A>): A;
    getOrNull(): A | null;
    getOrUndefined(): A | undefined;
    flatMap<B>(f: (a: A) => Option<B>): Option<B>;
    flatten<B>(this: Option<Option<B>>): Option<B>;
    foldMap<M>(M: Monoid<M>): (f: (a: A) => M) => M;
    foldMapK<F>(F: MonoidK<F>): <B>(f: (a: A) => Kind<F, [B]>) => Kind<F, [B]>;
    foldLeft<B>(z: B, f: (b: B, a: A) => B): B;
    foldRight<B>(ez: Eval<B>, f: (a: A, eb: Eval<B>) => Eval<B>): Eval<B>;
    traverse<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Option<B>]>;
    traverseFilter<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [Option<B>]>) => Kind<G, [Option<B>]>;
    equals<A>(this: Option<A>, that: Option<A>, E?: Eq<A>): boolean;
}
export declare const Some: <A>(a: A) => Option<A>;
export declare const None: Option<never>;
interface OptionObj {
    <A>(value: A | null | undefined): Option<A>;
    pure<A>(value: A): Option<A>;
    fromNullable<A>(value: A | null | undefined): Option<A>;
    fromEither<A>(ea: Either<unknown, A>): Option<A>;
    tailRecM_<A, B>(a: A, f: (a: A) => Option<Either<A, B>>): Option<B>;
    Eq<A>(a: Eq<A>): Eq<Option<A>>;
    EqK: EqK<OptionF>;
    Functor: Functor<OptionF>;
    FunctorFilter: FunctorFilter<OptionF>;
    CoflatMap: CoflatMap<OptionF>;
    Alternative: Alternative<OptionF>;
    Monad: Monad<OptionF>;
    TraversableFilter: TraversableFilter<OptionF>;
}
interface _Option<A> extends HKT<OptionF, [A]> {
}
/**
 * @category Type Constructor
 * @category Data
 */
export interface OptionF extends TyK<[unknown]> {
    [$type]: Option<TyVar<this, 0>>;
}
export {};
//# sourceMappingURL=option.d.ts.map