export declare enum adtn {
    ap = "babakness/ap",
    map = "babakness/map",
    chain = "babakness/chain",
    flatMap = "babakness/flatMap"
}
declare global {
    interface ArrayConstructor {
        _URI: 'Array';
    }
    interface Array<T> {
        [adtn.ap]: <U>(a: any) => Array<U>;
        of: Array<T>;
    }
}
export declare type EntryKeyValue<A> = A extends [infer KEY, infer VALUE] ? [KEY, VALUE] : undefined;
export declare type EntryKey<A> = A extends [infer KEY, infer VALUE] ? KEY : undefined;
export declare type EntryValue<A> = A extends [infer KEY, infer VALUE] ? VALUE : undefined;
export declare type Flat = number | string | symbol;
export declare type Entry<A> = [Flat, A][];
export declare type Obj<T> = {
    [k: string]: T;
};
export declare type Predicate<A> = (x: A) => boolean;
export declare type Predicate2<A, B> = (x: A, y: B) => boolean;
export declare type Complement<T extends boolean> = Exclude<boolean, T> extends never ? boolean : Exclude<boolean, T>;
export declare type FlattenArray<T> = T extends any[][] ? T[number] : T;
export declare type Omit<T, K extends keyof T> = T extends any ? Pick<T, Exclude<keyof T, K>> : never;
export declare type Optional<T, K extends keyof T> = T extends any ? Omit<T, K> & {
    [P in K]?: T[K];
} : never;
export declare type ValueAt<G, I extends keyof G> = G[I];
export declare type ValueOf<T> = T[keyof T];
export declare type KeyTypes = string | number | symbol;
export declare type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
export declare type Function1<A, B> = (a: A) => B;
export declare type Function2<A, B, C> = (a: A, b: B) => C;
export declare type Function3<A, B, C, D> = (a: A, b: B, c: C) => D;
export declare type Function4<A, B, C, D, E> = (a: A, b: B, c: C, d: D) => E;
export declare type Function5<A, B, C, D, E, F> = (a: A, b: B, c: C, d: D, e: E) => F;
export declare type Function6<A, B, C, D, E, F, G> = (a: A, b: B, c: C, d: D, e: E, f: F) => G;
export declare type Function7<A, B, C, D, E, F, G, H> = (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H;
export declare type Function8<A, B, C, D, E, F, G, H, I> = (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => I;
export declare type Function9<A, B, C, D, E, F, G, H, I, J> = (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => J;
export declare type FunctionV<A, B> = (...a: A[]) => B;
export declare type Function_21<A, B, C, D> = (a: A, b: B) => (c: C) => D;
export declare type Function_211<A, B, C, D, E> = (a: A, b: B) => (c: C) => (d: D) => E;
export declare type Function_22<A, B, C, D, E> = (a: A, b: B) => (c: C, d: D) => E;
export declare type Function_31<A, B, C, D, E> = (a: A, b: B, c: C) => (d: D) => E;
export declare type Function_2111<A, B, C, D, E, F> = (a: A, b: B) => (c: C) => (d: D) => (e: E) => F;
export declare type Function_311<A, B, C, D, E, F> = (a: A, b: B, c: C) => (d: D) => (e: E) => F;
export declare type Function_41<A, B, C, D, E, F> = (a: A, b: B, c: C, d: D) => (e: E) => F;
export declare type Function_51<A, B, C, D, E, F, G> = (a: A, b: B, c: C, d: D, e: E) => (f: F) => G;
export declare type Function_61<A, B, C, D, E, F, G, H> = (a: A, b: B, c: C, d: D, e: E, f: F) => (g: G) => H;
export declare type Curried2<A, B, C> = (a: A) => (b: B) => C;
export declare type Curried3<A, B, C, D> = (a: A) => (b: B) => (c: C) => D;
export declare type Curried4<A, B, C, D, E> = (a: A) => (b: B) => (c: C) => (d: D) => E;
export declare type Curried5<A, B, C, D, E, F> = (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => F;
export declare type Curried6<A, B, C, D, E, F, G> = (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => (f: F) => G;
export declare type Curried7<A, B, C, D, E, F, G, H> = (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => (f: F) => (g: G) => H;
export declare type Curried8<A, B, C, D, E, F, G, H, I> = (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => (f: F) => (g: G) => (h: H) => I;
export declare type Curried9<A, B, C, D, E, F, G, H, I, J> = (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => (f: F) => (g: G) => (h: H) => (i: I) => J;
export interface Functor<A> {
    map<B>(fn: Function1<A, B>): Functor<B>;
}
export interface Apply<A> extends Functor<A> {
    ap<B>(fn: Apply<(a: A) => B>): Apply<B>;
}
export interface ArrayApply<A> extends Functor<A> {
    [adtn.ap]<B>(fn: Apply<(a: A) => B>): ArrayApply<B>;
}
export interface Applicative<A> {
    of(val: A): Apply<A>;
}
export interface Applicative<A> {
    of(val: A): Apply<A>;
}
export interface ArrayApplicative<F, A> {
    _URI: F;
    of(val: A): ArrayApply<A>;
}
export interface Filterable<A> {
    filter(fn: Predicate<A>): Filterable<A>;
}
export interface HKT0<F> {
    readonly _URI: F;
}
export interface Pushable<A> {
    readonly concat: (item: A) => Pushable<A>;
}
export interface Concattable<A> {
    readonly concat: (item: A) => Concattable<A>;
}
export interface PossiblyCurried<A, B, Z> {
    (b: B, a: A): Z;
    (b: B): (a: A) => Z;
}
export declare type ToTuple<T> = T extends any[] ? T : any[];
export declare type Head<Tuple extends any[]> = Tuple extends [infer H, ...any[]] ? H : never;
export declare type Tail<Tuple extends any[]> = ((...t: Tuple) => void) extends ((h: any, ...rest: infer R) => void) ? R : never;