/** @module helper-types.ts */
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) => U[];
        of: 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 Pairs<A, B> = Array<[A, B]>;
export interface 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[Exclude<keyof T, keyof any[]>];
export declare type KeyOf<T> = Exclude<keyof T, keyof any[]>;
export declare type KeyTypes = string | number | symbol;
export declare type Unpacked<T> = T extends Array<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 Curried1<A, B> = (a: A) => B;
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 Curried<A, B, Z> {
    (b: B, a: A): Z;
    (b: B): (a: A) => Z;
}
export declare type FunctionPropertyNames<T> = {
    [K in keyof T]: T[K] extends AnyFunction ? K : never;
}[keyof T];
export declare type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
export declare type ObjectPropertyNamesByType<O, T> = {
    [K in keyof O]: O[K] extends T ? K : never;
}[keyof O];
export declare type ObjectPropertiesByType<O, T> = Pick<O, ObjectPropertyNamesByType<O, T>>;
export declare type ToTuple<T> = T extends any[] ? T : any[];
declare type AnyArray = any[];
export declare type Prepend<Tuple extends AnyArray, Addend> = ((_: Addend, ..._1: Tuple) => any) extends ((..._: infer Result) => any) ? Result : never;
export declare type Last<Tuple extends AnyArray, Default = never> = {
    'empty': Default;
    'single': Tuple extends [infer SoleElement] ? SoleElement : never;
    'multi': ((..._: Tuple) => any) extends ((_: any, ..._1: infer Next) => any) ? Last<Next> : Default;
    'infinite': Tuple extends Array<infer Element> ? Element : never;
}[Tuple extends [] ? 'empty' : Tuple extends [any] ? 'single' : Tuple extends Array<infer Element> ? Element[] extends Tuple ? 'infinite' : 'multi' : never];
export declare type Reverse<Tuple extends AnyArray, Prefix extends any[] = []> = {
    'empty': Prefix;
    'nonEmpty': ((..._: Tuple) => any) extends ((_: infer First, ..._1: infer Next) => any) ? Reverse<Next, Prepend<Prefix, First>> : never;
    'infinite': {
        ERROR: 'xCannot reverse an infinite tuple';
        CODENAME: 'InfiniteTuple';
    };
}[Tuple extends [any, ...any[]] ? IsFinite<Tuple, 'nonEmpty', 'infinite'> : 'empty'];
export declare type IsFinite<Tuple extends AnyArray, Finite = true, Infinite = false> = {
    empty: Finite;
    nonEmpty: ((..._: Tuple) => any) extends ((_: infer First, ..._1: infer Rest) => any) ? IsFinite<Rest, Finite, Infinite> : never;
    infinite: Infinite;
}[Tuple extends [] ? 'empty' : Tuple extends Array<infer Element> ? Element[] extends Tuple ? 'infinite' : 'nonEmpty' : never];
declare type _Concat<Left extends any[], Right extends any[]> = {
    'emptyLeft': Right;
    'singleLeft': Left extends [infer SoleElement] ? Prepend<Right, SoleElement> : never;
    'multiLeft': ((..._: Reverse<Left>) => any) extends ((_: infer LeftLast, ..._1: infer ReversedLeftRest) => any) ? _Concat<Reverse<ReversedLeftRest>, Prepend<Right, LeftLast>> : never;
    'infiniteLeft': {
        ERROR: 'Left is not finite';
        CODENAME: 'InfiniteLeft' & 'Infinite';
    };
}[Left extends [] ? 'emptyLeft' : Left extends [any] ? 'singleLeft' : IsFinite<Left, 'multiLeft', 'infiniteLeft'>];
export declare type Tail<Tuple extends AnyArray> = ((...t: Tuple) => void) extends ((h: any, ...rest: infer R) => void) ? R : never;
export declare type Init<Tuple extends AnyArray> = Reverse<Tail<Reverse<Tuple>>>;
export declare type FlattenOnce<T extends any[]> = DeepFlatten<T, [], 'next'>;
export declare type Append<A extends any[], B> = Reverse<Prepend<Reverse<A>, B>>;
export declare type Concat<A extends any[], B> = B extends any[] ? _Concat<A, B> : Append<A, B>;
export declare type Head<A extends any[]> = ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? First : ValueAt<A, 0>;
/** Essentials */
export declare type Primitive = string | number | boolean | undefined | null;
/** Dictionaries related */
export declare type Dictionary<T, K extends string | number = string> = {
    [key in K]: T;
};
export declare type DictionaryValues<T> = T extends Dictionary<infer U> ? U : never;
/** Like Partial but recursive */
export declare type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer UU> ? ReadonlyArray<DeepPartial<UU>> : DeepPartial<T[P]>;
};
export declare type StrictPartial<O, P> = {
    [K in keyof P]: K extends keyof O ? O[K] : never;
};
export declare type DeepPartialFlexibleType<T> = {
    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartialFlexibleType<U>> : T[P] extends ReadonlyArray<infer UU> ? ReadonlyArray<DeepPartialFlexibleType<UU>> : DeepPartialFlexibleType<unknown>;
};
/** Like Readonly but recursive */
export declare type DeepReadonly<T> = T extends Primitive ? T : T extends Array<infer U> ? ReadonlyArray<U> : T extends AnyFunction ? T : DeepReadonlyObject<T>;
declare type DeepReadonlyObject<T> = {
    readonly [P in keyof T]: DeepReadonly<T[P]>;
};
/** Easy create opaque types ie. types that are subset of their original types (ex: positive numbers, uppercased string) */
export declare type Opaque<K, T> = T & {
    __TYPE__: K;
};
export declare type FlattenType<A extends any[]> = {
    'deeper': A extends Array<infer U> ? U extends any[] ? FlattenType<U> : never : never;
    'done': A extends Array<infer U> ? U : never;
}[A extends Array<Array<infer U>> ? 'deeper' : 'done'];
export declare type Identity = <A>(a: A) => A;
export declare type WidenType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends symbol ? symbol : T extends Function ? Function : T extends object ? object : T extends undefined ? undefined : T extends null ? null : T;
declare type _Deeper = 'deeper' | 'next';
declare type _Pass = 'flattenType' | 'markInfinite' | 'error' | 'pass';
declare type _Advance = 'advance' | 'advanceWide';
export declare type DeepFlatten<A extends any[], N extends any[] = [], Deeper extends _Deeper = 'deeper', Advance extends _Advance = 'advance', Pass extends _Pass = 'pass'> = {
    'advance': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? _Concat<N, First> : never, Deeper, Advance, Pass> : never;
    'advanceWide': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? _Concat<N, WidenType<First>> : never, Deeper, Advance, Pass> : never;
    'deeper': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? _Concat<N, DeepFlatten<First>> : never, Deeper, Advance, Pass> : never;
    'pass': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? Append<N, First> : never, Deeper, Advance, Pass> : never;
    'flattenType': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? Append<N, FlattenType<First>> : never, Deeper, Advance, Pass> : never;
    'markInfinite': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? DeepFlatten<Next, N extends any[] ? _Concat<N, 'infinite'> : never, Deeper, Advance, Pass> : never;
    'error': {
        ERROR: 'Infinite Item';
        TEXT: 'Encountered an infinite item, evaluation haulted';
    };
    'done': N;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? First extends any[] ? IsFinite<First> extends true ? Deeper : Pass : 'advance' : never];
export declare type BasicTypes = string | number | boolean | symbol | object | undefined | null | void | never;
export declare type WidenArray<T extends any[]> = T extends Array<infer U> ? U[] : T;
/**
 * Deeply flattens a tuple and widens literals to general types
 */
export declare type DeepFlattenAndGeneralizeTuple<T extends any[]> = WidenArray<DeepFlatten<T, [], 'deeper', 'advanceWide', 'flattenType'>>;
export declare type ContainsInfinite<A extends any[], N extends any[] = []> = {
    'next': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? ContainsInfinite<Next, Prepend<N, First>> : never;
    'done': false;
    'found': true;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? IsFinite<First> extends true ? 'next' : 'found' : 'done'];
export declare type ContainsType<A extends any[], T, N extends any[] = []> = {
    'next': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? ContainsType<Next, Prepend<N, First>> : never;
    'done': false;
    'found': true;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? T extends First ? 'found' : 'next' : 'done'];
declare type _DeepFlattenNoInfinite<T extends any[]> = ContainsInfinite<T> extends true ? DeepFlattenAndGeneralizeTuple<T> : T;
/**
 * Deeply flatten a type, keeps literals unless there is an infinite type found
 */
export declare type DeepFlattenNoInfinite<T extends any[]> = {
    'generalize': _DeepFlattenNoInfinite<T>;
}[T extends any[] ? 'generalize' : never];
export declare type Equals<A, B, T = true, F = false> = A extends B ? B extends A ? T : F : F;
export declare type Contains<A extends any[], V, T = true, F = false> = {
    'next': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? Contains<Next, V, T, F> : never;
    'found': T;
    'done': F;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? Equals<First, V, 'found', 'next'> : never];
export declare type Unique<A extends any[], R extends any[] = [], O extends any[] = A> = {
    'exclude': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? Unique<Next, R, O> : never;
    'include': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? R extends ([] | [any, ...any[]]) ? Unique<Next, Append<R, First>, O> : Unique<Next, R, O> : never;
    'never': 'never';
    'simplify': WidenArray<O>;
    'done': R;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? IsFinite<First> extends true ? Contains<R, First, 'exclude', 'include'> : 'simplify' : never];
export declare type AppendUnique<A extends any[], Item> = {
    'next': Append<A, Item>;
    'done': A;
}[Contains<A, Item, 'done', 'next'>];
export declare type Indices<T> = Exclude<keyof T, keyof any[]>;
export declare type Literal<A extends BasicTypes, B extends [A, ...A[]] = [A, ...A[]], C extends [B, ...B[]] = [B, ...B[]], Narrow extends BasicTypes | [(A | B | C), ...Array<A | B | C>] = [(A | B | C), ...Array<A | B | C>]> = Narrow;
export declare type KeySubset<E, I> = Exclude<keyof E, Extract<keyof E, keyof I>> extends never ? true : false;
export declare type HashKey = 'uuS*4_G]Sv<4eu-P""1giCjl3K~nLl[m>ePO9m/1ys?7:LH&A)MCr:a8g{X};8b';
export declare type IsAny<O, T = true, F = false> = HashKey extends O ? any extends O ? T : F : F;
export declare type ContainsAny<A extends any[], T = true, F = false, N extends any[] = []> = {
    'next': ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? ContainsAny<Next, T, F, Prepend<N, First>> : never;
    'found': T;
    'done': F;
}[A extends [] ? 'done' : ((..._: A) => any) extends ((_: infer First, ..._1: infer Next) => any) ? IsAny<First, 'found', 'next'> : 'done'];
export declare type AnyObject = {
    [K in string]: any;
};
export declare type IsArray<A, T = true, F = false> = A extends Array<infer U> ? T : F;
export declare type Merge<A extends AnyObject, B extends AnyObject, C extends A & B = A & B> = {
    'merge': {
        [I in keyof C]: I extends keyof B ? B[I] : C[I];
    };
    'done': {
        [I in string]: unknown;
    };
    'array': 'ERROR: this type function is not design to merge arrays';
}[IsArray<A, 'array', IsArray<B, 'array', Contains<[A, B], object, 'done', 'merge'>>>];
export declare type AnyFunction = (...args: any[]) => any;
export declare type ExtractFunctionArguments<Fn> = Fn extends (...args: infer P) => any ? P : never;
export declare type ExtractFunctionReturnValue<Fn> = Fn extends (...args: any[]) => infer P ? P : never;
export declare type ItemInsideIterable<I> = {
    'iterable': I extends Iterable<infer U> ? U : never;
    'nodelist': I extends NodeListOf<infer U> ? U : never;
}[I extends Iterable<any> ? 'iterable' : I extends NodeListOf<any> ? 'nodelist' : never];
export {};