/**
 * This file contains the Nil algebraic data type. Nil is a native form of the
 * Option algebraic data type. Instead of encapsulating a value in a tagged
 * union it uses the native `undefined` and `null` types built in to javascript.
 * Unfortunately, this makes its algebraic structure implementations unsound in
 * some cases, specifically when one wants to use undefined or null as
 * significant values (meaning they have some meaning beyond empty).
 *
 * @module Nil
 * @since 2.0.0
 */
import "./_dnt.polyfills.js";
import type { $, Kind, Out } from "./kind.js";
import type { Applicable } from "./applicable.js";
import type { Combinable } from "./combinable.js";
import type { Comparable } from "./comparable.js";
import type { Either } from "./either.js";
import type { Filterable } from "./filterable.js";
import type { Flatmappable } from "./flatmappable.js";
import type { Foldable } from "./foldable.js";
import type { Initializable } from "./initializable.js";
import type { Mappable } from "./mappable.js";
import type { Option } from "./option.js";
import type { Pair } from "./pair.js";
import type { Predicate } from "./predicate.js";
import type { Refinement } from "./refinement.js";
import type { Showable } from "./showable.js";
import type { Sortable } from "./sortable.js";
import type { Traversable } from "./traversable.js";
import type { Wrappable } from "./wrappable.js";
/**
 * @since 2.0.0
 */
export type Nil<A> = A | undefined | null;
/**
 * @since 2.0.0
 */
export interface KindNil extends Kind {
    readonly kind: Nil<Out<this, 0>>;
}
/**
 * @since 2.0.0
 */
export declare function nil<A = never>(a: A): Nil<A>;
/**
 * @since 2.0.0
 */
export declare function init<A = never>(): Nil<A>;
/**
 * @since 2.0.0
 */
export declare function fail<A = never>(): Nil<A>;
/**
 * @since 2.0.0
 */
export declare function fromPredicate<A, B extends A>(refinement: Refinement<A, B>): (a: A) => Nil<B>;
export declare function fromPredicate<A>(predicate: Predicate<A>): (ta: Nil<A>) => Nil<A>;
/**
 * @since 2.0.0
 */
export declare function fromOption<A>(ua: Option<A>): Nil<A>;
/**
 * @since 2.0.0
 */
export declare function tryCatch<D extends unknown[], A>(fda: (...d: D) => A): (...d: D) => Nil<A>;
/**
 * @since 2.0.0
 */
export declare function match<A, I>(onNil: () => I, onValue: (a: A) => I): (ta: Nil<A>) => I;
/**
 * @since 2.0.0
 */
export declare function getOrElse<A>(onNil: () => A): (ta: Nil<A>) => A;
/**
 * @since 2.0.0
 */
export declare function toNull<A>(ta: Nil<A>): A | null;
/**
 * @since 2.0.0
 */
export declare function toUndefined<A>(ta: Nil<A>): A | undefined;
/**
 * @since 2.0.0
 */
export declare function isNil<A>(ta: Nil<A>): ta is undefined | null;
/**
 * @since 2.0.0
 */
export declare function isNotNil<A>(ta: Nil<A>): ta is NonNullable<A>;
/**
 * @since 2.0.0
 */
export declare function wrap<A>(a: A): Nil<A>;
/**
 * @since 2.0.0
 */
export declare function apply<A>(ua: Nil<A>): <I>(ufai: Nil<(a: A) => I>) => Nil<I>;
/**
 * @since 2.0.0
 */
export declare function map<A, I>(fai: (a: A) => I): (ta: Nil<A>) => Nil<I>;
/**
 * @since 2.0.0
 */
export declare function flatmap<A, I>(fati: (a: A) => Nil<I>): (ta: Nil<A>) => Nil<I>;
/**
 * @since 2.0.0
 */
export declare function alt<A>(tb: Nil<A>): (ta: Nil<A>) => Nil<A>;
/**
 * @since 2.0.0
 */
export declare function exists<A>(predicate: Predicate<A>): (ua: Nil<A>) => boolean;
/**
 * @since 2.0.0
 */
export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (ta: Nil<A>) => Nil<B>;
export declare function filter<A>(predicate: Predicate<A>): (ta: Nil<A>) => Nil<A>;
/**
 * @since 2.0.0
 */
export declare function filterMap<A, I>(fai: (a: A) => Option<I>): (ua: Nil<A>) => Nil<I>;
/**
 * @since 2.0.0
 */
export declare function partition<A, B extends A>(refinement: Refinement<A, B>): (ua: Nil<A>) => Pair<Nil<B>, Nil<A>>;
export declare function partition<A>(predicate: Predicate<A>): (ua: Nil<A>) => Pair<Nil<A>, Nil<A>>;
/**
 * @since 2.0.0
 */
export declare function partitionMap<A, I, J>(fai: (a: A) => Either<J, I>): (ua: Nil<A>) => Pair<Nil<I>, Nil<J>>;
/**
 * @since 2.0.0
 */
export declare function traverse<V extends Kind>(A: Applicable<V>): <A, I, J, K, L, M>(favi: (a: A) => $<V, [I, J, K], [L], [M]>) => (ta: Nil<A>) => $<V, [Nil<I>, J, K], [L], [M]>;
/**
 * @since 2.0.0
 */
export declare function fold<A, O>(reducer: (accumulator: O, current: A) => O, initial: O): (ua: Nil<A>) => O;
/**
 * @since 2.0.0
 */
export declare function getShowableNil<A>({ show }: Showable<A>): Showable<Nil<A>>;
/**
 * @since 2.0.0
 */
export declare function getComparableNil<A>({ compare }: Comparable<A>): Comparable<Nil<A>>;
/**
 * @since 2.0.0
 */
export declare function getSortableNil<A>({ sort }: Sortable<A>): Sortable<Nil<A>>;
/**
 * @since 2.0.0
 */
export declare function getCombinableNil<A>({ combine }: Combinable<A>): Combinable<Nil<A>>;
/**
 * @since 2.0.0
 */
export declare function getInitializableNil<A>(I: Initializable<A>): Initializable<Nil<A>>;
/**
 * @since 2.0.0
 */
export declare const ApplicableNil: Applicable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const MappableNil: Mappable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const FilterableNil: Filterable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const FlatmappableNil: Flatmappable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const FoldableNil: Foldable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const TraversableNil: Traversable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const WrappableNil: Wrappable<KindNil>;
/**
 * @since 2.0.0
 */
export declare const tap: <A>(fn: (value: A) => void) => <B = never, C = never, D = unknown, E = unknown>(ua: Nil<A>) => Nil<A>;
/**
 * @since 2.0.0
 */
export declare const bind: <N extends string, A, I, J = never, K = never, L = unknown, M = unknown>(name: Exclude<N, keyof A>, faui: (a: A) => Nil<I>) => <B = never, C = never, D extends L = L>(ua: Nil<A>) => Nil<{ readonly [K_1 in N | keyof A]: K_1 extends keyof A ? A[K_1] : I; }>;
/**
 * @since 2.0.0
 */
export declare const bindTo: <N extends string>(name: N) => <A, B = never, C = never, D = unknown, E = unknown>(ua: Nil<A>) => Nil<{ readonly [K in N]: A; }>;