import * as tfunctor from '../../typeclass/functor';
import * as tOf from '../../typeclass/of';
import * as tTo from '../../typeclass/to';
import * as tNone from '../../typeclass/none';
import * as tApplicative from '../../typeclass/applicative';
import * as tMonad from '../../typeclass/monad';
import * as tFoldable from '../../typeclass/foldable';
import * as tFilterable from '../../typeclass/filterable';
import * as tSemiAlternative from '../../typeclass/semialternative';
import * as tAlternative from '../../typeclass/alternative';
import * as tSemiAlign from '../../typeclass/semialign';
import type { Option, TOption } from './option.types';
/**
 * produce none Option of type a
 *
 * none :: `() -> Option<a>`
 *
 * none :: `<...>() => none`
 *
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(none(), map(x => x + 1)) // none
 * ```
 */
export declare const none: <A = never>() => Option<A>;
/**
 * produce some Option of type a
 *
 * some :: `a -> Option<a>`
 *
 * some :: `<A>(a: A) => Option<A>`
 *
 * @param a any value
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(1), map(x => x + 1)) // some(2)
 * ```
 */
export declare const some: <A>(a: A) => Option<A>;
/**
 * isNone :: `Option<a> -> boolean`
 *
 * isNone :: `<A>(option: Option<A>) => option is None<A>`
 *
 * @param option `Option<a>`
 * @returns  `boolean`
 *
 * @example
 * ```ts
 * pipe(some(1), isNone) // false
 * pipe(none, isNone) // true
 * ```
 */
export declare const isNone: <A>(option: Option<A>) => option is Option.None<A>;
/**
 * isSome :: `Option<a> -> boolean`
 *
 * isSome :: `<A>(option: Option<A>) => option is Some<A>`
 *
 * @param option `Option<a>`
 * @returns  `boolean`
 *
 * @example
 * ```ts
 * pipe(some(1), isSome) // true
 * pipe(none, isSome) // false
 * ```
 */
export declare const isSome: <A>(option: Option<A>) => option is Option.Some<A>;
/**
 * fromNullable :: `a | null | undefined -> Option<a>`
 *
 * fromNullable :: `<A>(a: A | null | undefined) => Option<A>`
 *
 * @param a `a | null | undefined`
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(1, fromNullable) // some(1)
 * pipe(null, fromNullable) // none
 * pipe(undefined, fromNullable) // none
 * ```
 */
export declare const fromNullable: <A>(a: A | null | undefined) => Option<A>;
/**
 * fromPredicate :: `(a -> boolean) -> a -> Option<a>`
 *
 * fromPredicate :: `<A>(predicate: (a: A) => boolean) => (a: A) => Option<A>`
 *
 * @param predicate `(a -> boolean)`
 * @returns `a -> Option<a>`
 *
 * @example
 * ```ts
 * pipe(1, fromPredicate(x => x > 1)) // none
 * pipe(2, fromPredicate(x => x > 1)) // some(2)
 * ```
 */
export declare const fromPredicate: <A>(predicate: (a: A) => boolean) => (a: A) => Option<A>;
/**
 * fromIterable :: `Iterable<a> -> Option<a>`
 *
 * fromIterable :: `<A>(iterable: Iterable<A>) => Option<A>`
 *
 * @param iterable `Iterable<a>`
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe([1, 2, 3], fromIterable) // some(1)
 * pipe([], fromIterable) // none
 * ```
 */
export declare const fromIterable: <A>(iterable: Iterable<A>) => Option<A>;
/**
 * toNullable :: `Option<a> -> a | null`
 *
 * toNullable :: `<A>(option: Option<A>) => A | null`
 *
 * @param option `Option<a>`
 * @returns `a | null`
 *
 * @example
 * ```ts
 * pipe(some(1), toNullable) // 1
 * pipe(none, toNullable) // null
 * ```
 */
export declare const toNullable: <A>(option: Option<A>) => A | null;
/**
 * toUndefined :: `Option<a> -> a | undefined`
 *
 * toUndefined :: `<A>(option: Option<A>) => A | undefined`
 *
 * @param option `Option<a>`
 * @returns `a | undefined`
 *
 * @example
 * ```ts
 * pipe(some(1), toUndefined) // 1
 * pipe(none, toUndefined) // undefined
 * ```
 */
export declare const toUndefined: <A>(option: Option<A>) => A | undefined;
export declare const None: tNone.None<TOption>;
export declare const Of: tOf.Of<TOption>;
export declare const To: tTo.To<TOption>;
export declare const Functor: tfunctor.Functor<TOption>;
export declare const SemiAlternative: tSemiAlternative.SemiAlternative<TOption>;
export declare const Foldable: tFoldable.Foldable<TOption>;
export declare const Filterable: tFilterable.Filterable<TOption>;
export declare const Applicative: tApplicative.Applicative<TOption>;
export declare const Alternative: tAlternative.Alternative<TOption>;
export declare const Monad: tMonad.Monad<TOption>;
export declare const SemiAlign: tSemiAlign.SemiAlign<TOption>;
export declare const match: <A, B, C>(onSome: (a: A) => B, onNone: () => C) => (fa: Option<A>) => B | C;
/**
 * of :: `a -> Option<a>`
 *
 * of :: `<A>(a: A) => Option<A>`
 *
 * @param a any value
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(1, of) // some(1)
 * ```
 */
export declare const of: <A>(a: A) => Option<A>;
/**
 * getOrElse :: `() -> b -> Option<a> -> a | b`
 *
 * getOrElse :: `<B>(f: () => B) => <A>(fa: Option<A>) => A | B`
 *
 * @param f `() -> b`
 * @returns `Option<a> -> a | b`
 *
 * @example
 * ```ts
 * pipe(some(1), getOrElse(() => 0)) // 1
 * pipe(none, getOrElse(() => 0)) // 0
 * ```
 */
export declare const getOrElse: <A1>(f: () => A1) => <A>(fa: Option<A>) => A1 | A;
/**
 * getOr :: `b -> Option<a> -> a | b`
 *
 * getOr :: `<B>(b: B) => <A>(fa: Option<A>) => A | B`
 *
 * @param b `b`
 * @returns `Option<a> -> a | b`
 *
 * @example
 * ```ts
 * pipe(some(1), getOr(0)) // 1
 * pipe(none, getOr(0)) // 0
 * ```
 */
export declare const getOr: <A1>(args_0: A1) => <B1>(args_0: Option<B1>) => A1 | B1;
/**
 * orElse :: `(() -> Option<a>) -> Option<a> -> Option<a>`
 *
 * orElse :: `<A>(fb: () => Option<A>) => (fa: Option<A>) => Option<A>`
 *
 * @param fb `() -> Option<a>`
 * @returns `Option<a> -> Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(1), orElse(() => some(2))) // some(1)
 * pipe(some(1), orElse(() => none)) // some(1)
 * pipe(none, orElse(() => some(2))) // some(2)
 * pipe(none, orElse(() => none)) // none
 * ```
 */
export declare const orElse: <A1>(args_0: () => Option<A1>) => (args_0: Option<A1>) => Option<A1>;
/**
 * or :: `Option<a> -> Option<a> -> Option<a>`
 *
 * or :: `<A>(fb: Option<A>) => (fa: Option<A>) => Option<A>`
 *
 * @param fb `Option<a>`
 * @returns `Option<a> -> Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(1), or(some(2))) // some(1)
 * pipe(some(1), or(none)) // some(1)
 * pipe(none, or(some(2))) // some(2)
 * pipe(none, or(none)) // none
 * ```
 */
export declare const or: <A1>(args_0: Option<A1>) => (args_0: Option<A1>) => Option<A1>;
/**
 * map :: `(a -> b) -> Option<a> -> Option<b>`
 *
 * map :: `<A, B>(f: (a: A) => B) => (fa: Option<A>) => Option<B>`
 *
 * @param f `a -> b`
 * @returns `Option<a> -> Option<b>`
 *
 * @example
 * ```ts
 * pipe(some(1), map(x => x + 1)) // some(2)
 * pipe(none, map(x => x + 1)) // none
 * ```
 */
export declare const map: <A1, A2>(args_0: (args_0: A1) => A2) => (args_0: Option<A1>) => Option<A2>;
/**
 * flap :: `a -> Option<(a -> b)> -> Option<b>`
 *
 * flap :: `<A>(a: A) => <B>(fab: Option<(a: A) => B>) => Option<B>`
 *
 * @param a `a`
 * @returns `Option<(a -> b)> -> Option<b>`
 *
 * @example
 * ```ts
 * pipe(some(x => x + 1), flap(0)) // some(1)
 * pipe(none, flap(0)) // none
 * ```
 */
export declare const flap: <A1>(args_0: A1) => <B1>(args_0: Option<(args_0: A1) => B1>) => Option<B1>;
/**
 * as :: `b -> Option<a> -> Option<b>`
 *
 * as :: `<B>(b: B) => <A>(fa: Option<A>) => Option<B>`
 *
 * @param b `b`
 * @returns `Option<a> -> Option<b>`
 *
 * @example
 * ```ts
 * pipe(some(1), as(0)) // some(0)
 * pipe(none, as(0)) // none
 * ```
 */
export declare const as: <A1>(args_0: A1) => <B1>(args_0: Option<B1>) => Option<A1>;
/**
 * tap :: `(a -> void) -> Option<a> -> Option<a>`
 *
 * tap :: `<A>(f: (a: A) => void) => (fa: Option<A>) => Option<A>`
 *
 * @param f `(a -> void)`
 * @returns `Option<a> -> Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(1), tap(console.log)) // some(1)
 * pipe(none, tap(console.log)) // none
 * ```
 */
export declare const tap: <A1>(args_0: (args_0: A1) => void) => (args_0: Option<A1>) => Option<A1>;
/**
 * doubleMap :: `(a -> b) -> Option<Option<a>> -> Option<Option<b>>`
 *
 * doubleMap :: `<A, B>(f: (a: A) => B) => (fa: Option<Option<A>>) => Option<Option<B>>`
 *
 * @param f `a -> b`
 * @returns `Option<Option<a>> -> Option<Option<b>>`
 *
 * @example
 * ```ts
 * pipe(some(some(1)), doubleMap(x => x + 1)) // some(some(2))
 * pipe(some(none), doubleMap(x => x + 1)) // some(none)
 * pipe(none, doubleMap(x => x + 1)) // none
 */
export declare const doubleMap: <A1, A2>(args_0: (args_0: A1) => A2) => (args_0: Option<Option<A1>>) => Option<Option<A2>>;
/**
 * ap :: `Option<a> -> Option<(a -> b)> -> Option<b>`
 *
 * ap :: `<A>(fa: Option<A>) => <B>(fab: Option<(a: A) => B>) => Option<B>`
 *
 * @param fa : Option<a>
 * @returns fab: Option<(a -> b)> -> Option<b>
 *
 * @example
 * ```ts
 * pipe(of(x => x + 1), ap(some(1))) // some(2)
 * pipe(of(x => x + 1), ap(none)) // none
 * pipe(none, ap(some(1))) // none
 * pipe(none, ap(none)) // none
 * ```
 */
export declare const ap: <A1>(args_0: Option<A1>) => <B1>(args_0: Option<(args_0: A1) => B1>) => Option<B1>;
/**
 * liftA2 :: `(a b -> c) -> Option<a> -> Option<b> -> Option<c>`
 *
 * liftA2 :: `<A, B, C>(f: (a: A, b: B) => C) => (fa: Option<A>) => (fb: Option<B>) => Option<C>`
 *
 * @param f `(a b -> c)`
 * @returns `Option<a> -> Option<b> -> Option<c>`
 *
 * @example
 * ```ts
 * pipe(liftA2((a, b) => a + b)(some(1))(some(2))) // some(3)
 * pipe(liftA2((a, b) => a + b)(some(1))(none())) // none()
 * pipe(liftA2((a, b) => a + b)(none())(some(2))) // none()
 * pipe(liftA2((a, b) => a + b)(none())(none())) // none()
 * ```
 */
export declare const liftA2: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => (args_0: Option<A1>) => (args_0: Option<A2>) => Option<A3>;
export declare const product: <A1>(args_0: Option<A1>) => <B1>(args_0: Option<B1>) => Option<[A1, B1]>;
export declare const productMany: <A1>(args_0: Option<A1>) => (args_0: Option<A1>[]) => Option<A1[]>;
/**
 * flatMap :: `(a -> Option<b>) -> Option<a> -> Option<b>`
 *
 * flatMap :: `<A, B>(f: (a: A) => Option<B>) => (fa: Option<A>) => Option<B>`
 *
 * @param f `a -> Option<b>`
 * @returns `Option<a> -> Option<b>`
 *
 * @example
 * ```ts
 * pipe(some(1), flatMap(x => some(x + 1))) // some(2)
 * pipe(none, flatMap(x => some(x + 1))) // none
 * ```
 */
export declare const flatMap: <A1, A2>(args_0: (args_0: A1) => Option<A2>) => (args_0: Option<A1>) => Option<A2>;
/**
 * alias for {@link flatMap}
 */
export declare const andThen: <A1, A2>(args_0: (args_0: A1) => Option<A2>) => (args_0: Option<A1>) => Option<A2>;
/**
 * alias for {@link flatMap}
 */
export declare const chain: <A1, A2>(args_0: (args_0: A1) => Option<A2>) => (args_0: Option<A1>) => Option<A2>;
/**
 * flatten :: `Option<Option<a>> -> Option<a>`
 *
 * flatten :: `<A>(ffa: Option<Option<A>>) => Option<A>`
 *
 * @param ffa `Option<Option<a>>`
 * @returns `Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(some(1)), flatten) // some(1)
 * pipe(some(none), flatten) // none
 * pipe(none, flatten) // none
 * ```
 */
export declare const flatten: <A1>(args_0: Option<Option<A1>>) => Option<A1>;
/**
 * reduce :: `(b a -> b) b -> Option<a> -> b`
 *
 * reduce :: `<B>(f: (b: B, a: A) => B, b: B) => (fa: Option<A>) => B`
 *
 * @param f `(b a -> b) b`
 * @param b `b`
 * @returns `Option<a> -> b`
 *
 * @example
 * ```ts
 * pipe(some(1), reduce((b, a) => b + a, 0)) // 1
 * pipe(none, reduce((b, a) => b + a, 0)) // 0
 * ```
 */
export declare const reduce: <A1, A2>(args_0: (args_0: A1, args_1: A2) => A1, args_1: A1) => (args_0: Option<A2>) => A1;
/**
 * filterMap :: `(a -> Option<b>) -> Option<a> -> Option<b>`
 *
 * filterMap :: `<A, B>(f: (a: A) => Option<B>) => (fa: Option<A>) => Option<B>`
 *
 * @param f `(a -> Option<b>)`
 * @returns `Option<a> -> Option<b>`
 *
 * @example
 * ```ts
 * pipe(some(1), filterMap(x => x > 1 ? some(x) : none)) // none
 * pipe(some(2), filterMap(x => x > 1 ? some(x) : none)) // some(2)
 * pipe(none, filterMap(x => x > 1 ? some(x) : none)) // none
 * ```
 */
export declare const filterMap: <A1, A2>(args_0: (args_0: A1) => Option<A2>) => (args_0: Option<A1>) => Option<A2>;
/**
 * filter :: `(a -> boolean) -> Option<a> -> Option<a>`
 *
 * filter :: `<A>(f: (a: A) => boolean) => (fa: Option<A>) => Option<A>`
 *
 * @param f `(a -> boolean)`
 * @returns `Option<a> -> Option<a>`
 *
 * @example
 * ```ts
 * pipe(some(1), filter(x => x > 1)) // none
 * pipe(some(2), filter(x => x > 1)) // some(2)
 * pipe(none, filter(x => x > 1)) // none
 * ```
 */
export declare const filter: <A1>(args_0: (args_0: A1) => boolean) => (args_0: Option<A1>) => Option<A1>;
export declare const compact: <A1>(args_0: Option<Option<A1>>) => Option<A1>;
export declare const pluck: <A, K extends keyof A>(k: K) => (args_0: Option<A>) => Option<A[K]>;
export declare const zipWith: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => (args_0: Option<A1>) => (args_0: Option<A2>) => Option<A3>;
export declare const zip: <A1>(args_0: Option<A1>) => <B1>(args_0: Option<B1>) => Option<[A1, B1]>;