@vinicunca/perkakas 0.0.3 → 0.0.5

package/dist/index.d.cts

@@ -0,0 +1,3221 @@
+/**
+ * Using event.code is not predictable since each machine may have different output
+ */
+declare const KEY_CODES: {
+    readonly TAB: "Tab";
+    readonly ARROW_DOWN: "ArrowDown";
+    readonly ARROW_UP: "ArrowUp";
+    readonly ARROW_LEFT: "ArrowLeft";
+    readonly ARROW_RIGHT: "ArrowRight";
+    readonly ENTER: "Enter";
+    readonly ESC: "Escape";
+    readonly SPACE: "Space";
+    readonly SHIFT: "Shift";
+    readonly KEY_F: "KEY_F";
+    readonly CTRL: "Control";
+    readonly ALT: "Alt";
+    readonly META: "Meta";
+    readonly AT: "@";
+    readonly DELETE: "Delete";
+    readonly BACKSPACE: "Backspace";
+    readonly HOME: "Home";
+    readonly END: "End";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageDown";
+};
+
+/**
+ * Determines whether all predicates returns true for the input data.
+ * @param data The input data for predicates.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.allPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(12, fns) // => true
+ *    P.allPass(8, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+declare function allPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether all predicates returns true for the input data.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.allPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.allPass(fns)(12) // => true
+ *    P.allPass(fns)(8) // => false
+ * @dataLast
+ * @category Array
+ */
+declare function allPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+
+/**
+ * Determines whether any predicate returns true for the input data.
+ * @param data The input data for predicates.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.anyPass(data, fns)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(8, fns) // => true
+ *    P.anyPass(11, fns) // => false
+ * @dataFirst
+ * @category Array
+ */
+declare function anyPass<T>(data: T, fns: ReadonlyArray<(data: T) => boolean>): boolean;
+/**
+ * Determines whether any predicate returns true for the input data.
+ * @param fns The list of predicates.
+ * @signature
+ *    P.anyPass(fns)(data)
+ * @example
+ *    const isDivisibleBy3 = (x: number) => x % 3 === 0
+ *    const isDivisibleBy4 = (x: number) => x % 4 === 0
+ *    const fns = [isDivisibleBy3, isDivisibleBy4]
+ *    P.anyPass(fns)(8) // => true
+ *    P.anyPass(fns)(11) // => false
+ * @dataLast
+ * @category Array
+ */
+declare function anyPass<T>(fns: ReadonlyArray<(data: T) => boolean>): (data: T) => boolean;
+
+type Pred<T, K> = (input: T) => K;
+type PredIndexed<T, K> = (input: T, index: number, array: Array<T>) => K;
+type PredIndexedOptional<T, K> = (input: T, index?: number, array?: Array<T>) => K;
+type NonEmptyArray<T> = [T, ...Array<T>];
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ *
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | [];
+
+type Chunked<T extends IterableContainer> = T[number] extends never ? [] : T extends readonly [unknown, ...Array<unknown>] | readonly [...Array<unknown>, unknown] ? NonEmptyArray<NonEmptyArray<T[number]>> : Array<NonEmptyArray<T[number]>>;
+/**
+ * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
+ * @param array the array
+ * @param size the length of the chunk
+ * @signature
+ *    P.chunk(array, size)
+ * @example
+ *    P.chunk(['a', 'b', 'c', 'd'], 2) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(['a', 'b', 'c', 'd'], 3) // => [['a', 'b', 'c'], ['d']]
+ * @dataFirst
+ * @category Array
+ */
+declare function chunk<T extends IterableContainer>(array: T, size: number): Chunked<T>;
+/**
+ * Split an array into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements.
+ * @param size the length of the chunk
+ * @signature
+ *    P.chunk(size)(array)
+ * @example
+ *    P.chunk(2)(['a', 'b', 'c', 'd']) // => [['a', 'b'], ['c', 'd']]
+ *    P.chunk(3)(['a', 'b', 'c', 'd']) // => [['a', 'b', 'c'], ['d']]
+ * @dataLast
+ * @category Array
+ */
+declare function chunk<T extends IterableContainer>(size: number): (array: T) => Chunked<T>;
+
+/**
+ * Filter out all falsey values. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey.
+ * @param items the array to compact
+ * @signature
+ *    P.compact(array)
+ * @example
+ *    P.compact([0, 1, false, 2, '', 3]) // => [1, 2, 3]
+ * @category Array
+ * @pipeable
+ */
+declare function compact<T>(items: ReadonlyArray<T | null | undefined | false | '' | 0>): Array<T>;
+
+/**
+ * Combines two arrays.
+ * @param arr1 the first array
+ * @param arr2 the second array
+ * @signature
+ *    P.concat(arr1, arr2);
+ * @example
+ *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
+ * @dataFirst
+ * @category Array
+ */
+declare function concat<T, K>(arr1: ReadonlyArray<T>, arr2: ReadonlyArray<K>): Array<T | K>;
+/**
+ * Combines two arrays.
+ * @param arr2 the second array
+ * @signature
+ *    P.concat(arr2)(arr1);
+ * @example
+ *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
+ * @dataLast
+ * @category Array
+ */
+declare function concat<T, K>(arr2: ReadonlyArray<K>): (arr1: ReadonlyArray<T>) => Array<T | K>;
+
+/**
+ * Counts how many values of the collection pass the specified predicate.
+ * @param items The input data.
+ * @param fn The predicate.
+ * @signature
+ *    P.countBy(array, fn)
+ * @example
+ *    P.countBy([1, 2, 3, 4, 5], x => x % 2 === 0) // => 2
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function countBy<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+declare function countBy<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => number;
+declare namespace countBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+}
+
+type LazyResult<T> = LazyEmpty | LazyNext<T> | LazyMany<T>;
+interface LazyEmpty {
+    done: boolean;
+    hasNext: false;
+    hasMany?: false | undefined;
+    next?: undefined;
+}
+interface LazyNext<T> {
+    done: boolean;
+    hasNext: true;
+    hasMany?: false | undefined;
+    next: T;
+}
+interface LazyMany<T> {
+    done: boolean;
+    hasNext: true;
+    hasMany: true;
+    next: Array<T>;
+}
+
+type IsEquals$1<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
+/**
+ * Excludes the values from `other` array.
+ * Elements are compared by custom comparator isEquals.
+ * @param array the source array
+ * @param other the values to exclude
+ * @param isEquals the comparator
+ * @signature
+ *    P.differenceWith(array, other, isEquals)
+ * @example
+ *    P.differenceWith(
+ *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}],
+ *      [{a: 2}, {a: 5}, {a: 3}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+declare function differenceWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, isEquals: IsEquals$1<TFirst, TSecond>): Array<TFirst>;
+/**
+ * Excludes the values from `other` array.
+ * Elements are compared by custom comparator isEquals.
+ * @param other the values to exclude
+ * @param isEquals the comparator
+ * @signature
+ *    P.differenceWith(other, isEquals)(array)
+ * @example
+ *    P.differenceWith(
+ *      [{a: 2}, {a: 5}, {a: 3}],
+ *      P.equals,
+ *    )([{a: 1}, {a: 2}, {a: 3}, {a: 4}]) // => [{a: 1}, {a: 4}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 3}, {a: 4}, {a: 5}, {a: 6}], // only 4 iterations
+ *      P.differenceWith([{a: 2}, {a: 3}], P.equals),
+ *      P.take(2),
+ *    ) // => [{a: 1}, {a: 4}]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+declare function differenceWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, isEquals: IsEquals$1<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+declare namespace differenceWith {
+    function lazy<TFirst, TSecond>(other: Array<TSecond>, isEquals: IsEquals$1<TFirst, TSecond>): (value: TFirst) => LazyResult<TFirst>;
+}
+
+/**
+ * Excludes the values from `other` array.
+ * @param array the source array
+ * @param other the values to exclude
+ * @signature
+ *    P.difference(array, other)
+ * @example
+ *    P.difference([1, 2, 3, 4], [2, 5, 3]) // => [1, 4]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+declare function difference<T>(array: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Excludes the values from `other` array.
+ * @param other the values to exclude
+ * @signature
+ *    P.difference(other)(array)
+ * @example
+ *    P.difference([2, 5, 3])([1, 2, 3, 4]) // => [1, 4]
+ *    P.pipe(
+ *      [1, 2, 3, 4, 5, 6], // only 4 iterations
+ *      P.difference([2, 3]),
+ *      P.take(2)
+ *    ) // => [1, 4]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+declare function difference<T, K>(other: ReadonlyArray<T>): (array: ReadonlyArray<K>) => Array<T>;
+declare namespace difference {
+    function lazy<T>(other: Array<T>): (value: T) => LazyResult<T>;
+}
+
+/**
+ * Removes last `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.dropLast(array, n)
+ * @example
+ *    P.dropLast([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropLast<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Removes last `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.dropLast(n)(array)
+ * @example
+ *    P.dropLast(2)([1, 2, 3, 4, 5]) // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+declare function dropLast<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Removes first `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.drop(array, n)
+ * @example
+ *    P.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+declare function drop<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Removes first `n` elements from the `array`.
+ * @param array the target array
+ * @param n the number of elements to skip
+ * @signature
+ *    P.drop(n)(array)
+ * @example
+ *    P.drop(2)([1, 2, 3, 4, 5]) // => [3, 4, 5]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function drop<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace drop {
+    function lazy<T>(n: number): (value: T) => LazyResult<T>;
+}
+
+/**
+ * Filter the elements of an array that meet the condition specified in a callback function.
+ * @param array The array to filter.
+ * @param fn the callback function.
+ * @signature
+ *    P.filter(array, fn)
+ *    P.filter.indexed(array, fn)
+ * @example
+ *    P.filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]
+ *    P.filter.indexed([1, 2, 3], (x, i, array) => x % 2 === 1) // => [1, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function filter<T, S extends T>(array: ReadonlyArray<T>, fn: (value: T) => value is S): Array<S>;
+declare function filter<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): Array<T>;
+/**
+ * Filter the elements of an array that meet the condition specified in a callback function.
+ * @param fn the callback function.
+ * @signature
+ *    P.filter(fn)(array)
+ *    P.filter.indexed(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3], P.filter(x => x % 2 === 1)) // => [1, 3]
+ *    P.pipe([1, 2, 3], P.filter.indexed((x, i) => x % 2 === 1)) // => [1, 3]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function filter<T, S extends T>(fn: (input: T) => input is S): (array: ReadonlyArray<T>) => Array<S>;
+declare function filter<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace filter {
+    function indexed<T, S extends T>(array: ReadonlyArray<T>, fn: (input: T, index: number, array: Array<T>) => input is S): Array<S>;
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): Array<T>;
+    /**
+     * @dataLast
+     */
+    function indexed<T, S extends T>(fn: (input: T, index: number, array: Array<T>) => input is S): (array: ReadonlyArray<T>) => Array<S>;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => Array<T>;
+    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
+        indexed: true;
+    };
+}
+
+/**
+ * Returns the index of the first element in the array where predicate is true, and -1 otherwise.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.findIndex(items, fn)
+ *    P.findIndex.indexed(items, fn)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ *    P.findIndex.indexed([1, 3, 4, 6], (n, i) => n % 2 === 0) // => 2
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findIndex<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+/**
+ * Returns the index of the first element in the array where predicate is true, and -1 otherwise.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.findIndex(fn)(items)
+ *    P.findIndex.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ) // => 2
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex.indexed((n, i) => n % 2 === 0)
+ *    ) // => 2
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findIndex<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => number;
+declare namespace findIndex {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+    const lazy: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: number;
+    } | {
+        done: boolean;
+        hasNext: boolean;
+        next?: undefined;
+    }) & {
+        single: true;
+    };
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: number;
+    } | {
+        done: boolean;
+        hasNext: boolean;
+        next?: undefined;
+    }) & {
+        indexed: true;
+    } & {
+        single: true;
+    };
+}
+
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1 otherwise.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.findLastIndex(items, fn)
+ *    P.findLastIndex.indexed(items, fn)
+ * @example
+ *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
+ *    P.findLastIndex.indexed([1, 3, 4, 6], (n, i) => n % 2 === 1) // => 1
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findLastIndex<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1 otherwise.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.findLastIndex(fn)(items)
+ *    P.findLastIndex.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex(n => n % 2 === 1)
+ *    ) // => 1
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex.indexed((n, i) => n % 2 === 1)
+ *    ) // => 1
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findLastIndex<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => number;
+declare namespace findLastIndex {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+}
+
+/**
+ * Returns the value of the last element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.findLast(items, fn)
+ *    P.findLast.indexed(items, fn)
+ * @example
+ *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
+ *    P.findLast.indexed([1, 3, 4, 6], (n, i) => n % 2 === 1) // => 3
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findLast<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): T | undefined;
+/**
+ * Returns the value of the last element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.findLast(fn)(items)
+ *    P.findLast.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast(n => n % 2 === 1)
+ *    ) // => 3
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast.indexed((n, i) => n % 2 === 1)
+ *    ) // => 3
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function findLast<T = never>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+declare namespace findLast {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+}
+
+/**
+ * Returns the value of the first element in the array where predicate is true, and undefined otherwise.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.find(items, fn)
+ *    P.find.indexed(items, fn)
+ * @example
+ *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
+ *    P.find.indexed([1, 3, 4, 6], (n, i) => n % 2 === 0) // => 4
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function find<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): T | undefined;
+/**
+ * Returns the value of the first element in the array where predicate is true, and undefined otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.find(fn)(items)
+ *    P.find.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find(n => n % 2 === 0)
+ *    ) // => 4
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find.indexed((n, i) => n % 2 === 0)
+ *    ) // => 4
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function find<T = never>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+declare namespace find {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+    const lazy: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: T;
+    }) & {
+        single: true;
+    };
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: T;
+    }) & {
+        indexed: true;
+    } & {
+        single: true;
+    };
+}
+
+type FirstOut<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Pre[0] | Last : T[0] | undefined;
+/**
+ * Gets the first element of `array`.
+ * Note: In `pipe`, use `first()` form instead of `first`. Otherwise, the inferred type is lost.
+ * @param array the array
+ * @signature
+ *    P.first(array)
+ * @example
+ *    P.first([1, 2, 3]) // => 1
+ *    P.first([]) // => undefined
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.first(),
+ *      x => x + 1
+ *    ); // => 5
+ *
+ * @category array
+ * @pipeable
+ */
+declare function first<T extends IterableContainer>(array: Readonly<T>): FirstOut<T>;
+declare function first<T extends IterableContainer>(): (array: Readonly<T>) => FirstOut<T>;
+declare namespace first {
+    function lazy<T>(): (value: T) => {
+        done: boolean;
+        hasNext: boolean;
+        next: T;
+    };
+    namespace lazy {
+        const single = true;
+    }
+}
+
+/**
+ * Map each element of an array into an object using a defined callback function and flatten the result.
+ * @param array The array to map.
+ * @param fn The mapping function, which should return an Array of key-value pairs, similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.flatMapToObj(array, fn)
+ *    P.flatMapToObj.indexed(array, fn)
+ * @example
+ *  P.flatMapToObj([1, 2, 3], (x) =>
+ *    x % 2 === 1 ? [[String(x), x]] : []
+ *  ) // => {1: 1, 3: 3}
+ *  P.flatMapToObj.indexed(['a', 'b'], (x, i) => [
+ *    [x, i],
+ *    [x + x, i + i],
+ *  ]) // => {a: 0, aa: 0, b: 1, bb: 2}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function flatMapToObj<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T) => Array<[K, V]>): Record<K, V>;
+/**
+ * Map each element of an array into an object using a defined callback function and flatten the result.
+ * @param fn The mapping function, which should return an Array of key-value pairs, similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.flatMapToObj(fn)(array)
+ *    P.flatMapToObj(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.flatMapToObj(x => (x % 2 === 1 ? [[String(x), x]] : []))
+ *    ) // => {1: 1, 3: 3}
+ *    P.pipe(
+ *      ['a', 'b'],
+ *      P.flatMapToObj.indexed((x, i) => [
+ *        [x, i],
+ *        [x + x, i + i],
+ *      ])
+ *    ) // => {a: 0, aa: 0, b: 1, bb: 2}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function flatMapToObj<T, K extends keyof any, V>(fn: (element: T) => Array<[K, V]>): (array: ReadonlyArray<T>) => Record<K, V>;
+declare namespace flatMapToObj {
+    function indexed<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => Array<[K, V]>): Record<K, V>;
+    function indexed<T, K extends keyof any, V>(fn: (element: T, index: number, array: ReadonlyArray<T>) => Array<[K, V]>): (array: ReadonlyArray<T>) => Record<K, V>;
+}
+
+/**
+ * Map each element of an array using a defined callback function and flatten the mapped result.
+ * @param array The array to map.
+ * @param fn The function mapper.
+ * @signature
+ *    P.flatMap(array, fn)
+ * @example
+ *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+declare function flatMap<T, K>(array: ReadonlyArray<T>, fn: (input: T) => K | Array<K>): Array<K>;
+/**
+ * Map each element of an array using a defined callback function and flatten the mapped result.
+ * @param array The array to map.
+ * @param fn The function mapper.
+ * @signature
+ *    P.flatMap(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function flatMap<T, K>(fn: (input: T) => K | Array<K>): (array: ReadonlyArray<T>) => Array<K>;
+declare namespace flatMap {
+    function lazy<T, K>(fn: (input: T) => K | Array<K>): (value: T) => {
+        done: boolean;
+        hasNext: boolean;
+        hasMany: boolean;
+        next: K[];
+    } | {
+        done: boolean;
+        hasNext: boolean;
+        next: K;
+        hasMany?: undefined;
+    };
+}
+
+type FlattenDeep<T> = T extends ReadonlyArray<infer K> ? FlattenDeep2<K> : T;
+type FlattenDeep2<T> = T extends ReadonlyArray<infer K> ? FlattenDeep3<K> : T;
+type FlattenDeep3<T> = T extends ReadonlyArray<infer K> ? FlattenDeep4<K> : T;
+type FlattenDeep4<T> = T extends ReadonlyArray<infer K> ? K : T;
+/**
+ * Recursively flattens `array`.
+ * Note: In `pipe`, use `flattenDeep()` form instead of `flattenDeep`. Otherwise, the inferred type is lost.
+ * @param items the target array
+ * @signature P.flattenDeep(array)
+ * @example
+ *    P.flattenDeep([[1, 2], [[3], [4, 5]]]) // => [1, 2, 3, 4, 5]
+ *    P.pipe(
+ *      [[1, 2], [[3], [4, 5]]],
+ *      P.flattenDeep(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @category Array
+ * @pipeable
+ */
+declare function flattenDeep<T>(items: ReadonlyArray<T>): Array<FlattenDeep<T>>;
+declare function flattenDeep<T>(): (items: ReadonlyArray<T>) => Array<FlattenDeep<T>>;
+declare namespace flattenDeep {
+    function lazy(): (value: any) => LazyResult<any>;
+}
+
+type Flatten<T> = T extends ReadonlyArray<infer K> ? K : T;
+/**
+ * Flattens `array` a single level deep.
+ * Note: In `pipe`, use `flatten()` form instead of `flatten`. Otherwise, the inferred type is lost.
+
+ * @param items the target array
+ * @signature P.flatten(array)
+ * @example
+ *    P.flatten([[1, 2], [3], [4, 5]]) // => [1, 2, 3, 4, 5]
+ *    P.pipe(
+ *      [[1, 2], [3], [4, 5]],
+ *      P.flatten(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @category Array
+ * @pipeable
+ */
+declare function flatten<T>(items: ReadonlyArray<T>): Array<Flatten<T>>;
+declare function flatten<T>(): (items: ReadonlyArray<T>) => Array<Flatten<T>>;
+declare namespace flatten {
+    function lazy<T>(): (next: T) => LazyResult<any>;
+}
+
+/**
+ * Iterate an array using a defined callback function. The original array is returned instead of `void`.
+ * @param array The array.
+ * @param fn The callback function.
+ * @returns The original array
+ * @signature
+ *    P.forEach(array, fn)
+ *    P.forEach.indexed(array, fn)
+ * @example
+ *    P.forEach([1, 2, 3], x => {
+ *      console.log(x)
+ *    }) // => [1, 2, 3]
+ *    P.forEach.indexed([1, 2, 3], (x, i) => {
+ *      console.log(x, i)
+ *    }) // => [1, 2, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function forEach<T>(array: ReadonlyArray<T>, fn: Pred<T, void>): Array<T>;
+/**
+ * Iterate an array using a defined callback function. The original array is returned instead of `void`.
+ * @param fn the function mapper
+ * @signature
+ *    P.forEach(fn)(array)
+ *    P.forEach.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.forEach(x => {
+ *        console.log(x)
+ *      })
+ *    ) // => [1, 2, 3]
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.forEach.indexed((x, i) => {
+ *        console.log(x, i)
+ *      })
+ *    ) // => [1, 2, 3]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function forEach<T>(fn: Pred<T, void>): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace forEach {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, void>): Array<T>;
+    function indexed<T>(fn: PredIndexed<T, void>): (array: ReadonlyArray<T>) => Array<T>;
+    const lazy: <T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
+        indexed: true;
+    };
+}
+
+interface Strict$5 {
+    <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: (item: Value) => Key | undefined): StrictOut$2<Value, Key>;
+    <Value, Key extends PropertyKey = PropertyKey>(fn: (item: Value) => Key | undefined): (items: ReadonlyArray<Value>) => StrictOut$2<Value, Key>;
+    readonly indexed: {
+        <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: PredIndexed<Value, Key | undefined>): StrictOut$2<Value, Key>;
+        <Value, Key extends PropertyKey = PropertyKey>(fn: PredIndexed<Value, Key | undefined>): (items: ReadonlyArray<Value>) => StrictOut$2<Value, Key>;
+    };
+}
+type StrictOut$2<Value, Key extends PropertyKey = PropertyKey> = string extends Key ? Record<Key, NonEmptyArray<Value>> : number extends Key ? Record<Key, NonEmptyArray<Value>> : symbol extends Key ? Record<Key, NonEmptyArray<Value>> : Partial<Record<Key, NonEmptyArray<Value>>>;
+/**
+ * Splits a collection into sets, grouped by the result of running each value through `fn`.
+ * @param items the items to group
+ * @param fn the grouping function. When `undefined` is returned the item would
+ * be skipped and not grouped under any key.
+ * @signature
+ *    P.groupBy(array, fn)
+ *    P.groupBy.strict(array, fn)
+ * @example
+ *    P.groupBy(['one', 'two', 'three'], x => x.length) // => {3: ['one', 'two'], 5: ['three']}
+ *    P.groupBy.strict([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]} typed Partial<Record<'cat' | 'dog', NonEmptyArray<{a: 'cat' | 'dog'}>>>
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @indexed
+ * @strict
+ * @category Array
+ */
+declare function groupBy<T>(items: ReadonlyArray<T>, fn: (item: T) => PropertyKey | undefined): Record<PropertyKey, NonEmptyArray<T>>;
+declare function groupBy<T>(fn: (item: T) => PropertyKey | undefined): (array: ReadonlyArray<T>) => Record<PropertyKey, NonEmptyArray<T>>;
+declare namespace groupBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, PropertyKey | undefined>): Record<string, NonEmptyArray<T>>;
+    function indexed<T>(fn: PredIndexed<T, PropertyKey | undefined>): (array: ReadonlyArray<T>) => Record<string, NonEmptyArray<T>>;
+    const strict: Strict$5;
+}
+
+/**
+ * Converts a list of objects into an object indexing the objects by the given key.
+ * @param array the array
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(array, fn)
+ * @example
+ *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function indexBy<T>(array: ReadonlyArray<T>, fn: (item: T) => any): Record<string, T>;
+/**
+ * Converts a list of objects into an object indexing the objects by the given key.
+ * @param array the array
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(fn)(array)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'three'],
+ *      P.indexBy(x => x.length)
+ *    ) // => {3: 'two', 5: 'three'}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function indexBy<T>(fn: (item: T) => any): (array: ReadonlyArray<T>) => Record<string, T>;
+declare namespace indexBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, any>): Record<string, T>;
+    function indexed<T>(fn: PredIndexed<T, any>): (array: ReadonlyArray<T>) => Record<string, T>;
+}
+
+/**
+ * Returns a list of elements that exist in both array.
+ * @param array the source array
+ * @param other the second array
+ * @signature
+ *    P.intersection(array, other)
+ * @example
+ *    P.intersection([1, 2, 3], [2, 3, 5]) // => [2, 3]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+declare function intersection<T>(source: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;
+/**
+ * Returns a list of elements that exist in both array.
+ * @param array the source array
+ * @param other the second array
+ * @signature
+ *    P.intersection(other)(array)
+ * @example
+ *    P.intersection([2, 3, 5])([1, 2, 3]) // => [2, 3]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+declare function intersection<T, K>(other: ReadonlyArray<T>): (source: ReadonlyArray<K>) => Array<T>;
+declare namespace intersection {
+    function lazy<T>(other: Array<T>): (value: T) => LazyResult<T>;
+}
+
+type Comparator<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ * @param array the source array
+ * @param other the second array
+ * @param comparator the custom comparator
+ * @signature
+ *    P.intersectionWith(array, other, comparator)
+ * @example
+ *    P.intersectionWith(
+ *      [
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ],
+ *      [3, 5],
+ *      (a, b) => a.id === b,
+ *    ) // => [{ id: 3, name: 'Emma' }]
+ * @dataFirst
+ * @category Array
+ * @pipeable
+ */
+declare function intersectionWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, comparator: Comparator<TFirst, TSecond>): Array<TFirst>;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ * @param other the second array
+ * @param comparator the custom comparator
+ * @signature
+ *    P.intersectionWith(other, comparator)(array)
+ * @example
+ *    P.intersectionWith(
+ *      [3, 5],
+ *      (a, b) => a.id === b
+ *      )([
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ]); // => [{ id: 3, name: 'Emma' }]
+ * @dataLast
+ * @category Array
+ * @pipeable
+ */
+declare function intersectionWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>, 
+/**
+ * type inference doesn't work properly for the comparator's first parameter
+ * in data last variant
+ */
+comparator: Comparator<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+declare namespace intersectionWith {
+    function lazy<TFirst, TSecond>(other: Array<TSecond>, comparator: Comparator<TFirst, TSecond>): (value: TFirst) => LazyResult<TFirst>;
+}
+
+type Joinable = bigint | boolean | number | string | null | undefined;
+type Joined<T extends IterableContainer, Glue extends string> = T[number] extends never ? '' : T extends readonly [Joinable?] ? `${NullishCoalesce<T[0], ''>}` : T extends readonly [infer First, ...infer Tail] ? `${NullishCoalesce<First, ''>}${Glue}${Joined<Tail, Glue>}` : T extends readonly [...infer Head, infer Last] ? `${Joined<Head, Glue>}${Glue}${NullishCoalesce<Last, ''>}` : string;
+type NullishCoalesce<T, Fallback> = T extends Joinable ? T extends undefined | null ? NonNullable<T> | Fallback : T : never;
+/**
+ * Joins the elements of the array by: casting them to a string and
+ * concatenating them one to the other, with the provided glue string in between
+ * every two elements.
+ *
+ * When called on a tuple and with stricter item types (union of literal values,
+ * the result is strictly typed to the tuples shape and it's item types).
+ *
+ * @param data The array to join
+ * @param glue The string to put in between every two elements
+ * @signature
+ *    P.join(data, glue)
+ * @example
+ *    P.join([1,2,3], ",") // => "1,2,3" (typed `string`)
+ *    P.join(['a','b','c'], "") // => "abc" (typed `string`)
+ *    P.join(['hello', 'world'] as const, " ") // => "hello world" (typed `hello world`)
+ * @dataFirst
+ * @category Array
+ */
+declare function join<T extends ReadonlyArray<Joinable> | [], Glue extends string>(data: T, glue: Glue): Joined<T, Glue>;
+/**
+ * Joins the elements of the array by: casting them to a string and
+ * concatenating them one to the other, with the provided glue string in between
+ * every two elements.
+ *
+ * When called on a tuple and with stricter item types (union of literal values,
+ * the result is strictly typed to the tuples shape and it's item types).
+ *
+ * @param data The array to join
+ * @param glue The string to put in between every two elements
+ * @signature
+ *    P.join(glue)(data)
+ * @example
+ *    P.pipe([1,2,3], P.join(",")) // => "1,2,3" (typed `string`)
+ *    P.pipe(['a','b','c'], P.join("")) // => "abc" (typed `string`)
+ *    P.pipe(['hello', 'world'] as const, P.join(" ")) // => "hello world" (typed `hello world`)
+ * @dataLast
+ * @category Array
+ */
+declare function join<T extends ReadonlyArray<Joinable> | [], Glue extends string>(glue: Glue): (data: T) => Joined<T, Glue>;
+
+/**
+ * Gets the last element of `array`.
+ * Note: In `pipe`, use `last()` form instead of `last`. Otherwise, the inferred type is lost.
+ * @param array the array
+ * @signature
+ *    P.last(array)
+ * @example
+ *    P.last([1, 2, 3]) // => 3
+ *    P.last([]) // => undefined
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.last(),
+ *      x => x + 1
+ *    ); // => 17
+ *
+ * @category Array
+ * @pipeable
+ */
+declare function last<T>(array: NonEmptyArray<T>): T;
+declare function last<T>(array: ReadonlyArray<T>): T | undefined;
+declare function last<T>(): (array: ReadonlyArray<T>) => T | undefined;
+
+type Enumerable<T> = ArrayLike<T> | Iterable<T>;
+/**
+ * Counts values of the collection or iterable.
+ * @param items The input data.
+ * @signature
+ *    P.length(array)
+ * @example
+ *    P.length([1, 2, 3]) // => 3
+ * @category Array
+ */
+declare function length<T>(items: Enumerable<T>): number;
+declare function length<T>(): (items: Enumerable<T>) => number;
+
+interface Strict$4 {
+    <T extends IterableContainer, K>(items: T, mapper: Pred<T[number], K>): StrictOut$1<T, K>;
+    <T extends IterableContainer, K>(mapper: Pred<T[number], K>): (items: T) => StrictOut$1<T, K>;
+    readonly indexed: {
+        <T extends IterableContainer, K>(items: T, mapper: PredIndexed<T[number], K>): StrictOut$1<T, K>;
+        <T extends IterableContainer, K>(mapper: PredIndexed<T[number], K>): (items: T) => StrictOut$1<T, K>;
+    };
+}
+type StrictOut$1<T extends IterableContainer, K> = {
+    -readonly [P in keyof T]: K;
+};
+/**
+ * Map each element of an array using a defined callback function. If the input
+ * array is a tuple use the `strict` variant to maintain it's shape.
+ * @param array The array to map.
+ * @param fn The function mapper.
+ * @returns The new mapped array.
+ * @signature
+ *    P.map(array, fn)
+ *    P.map.indexed(array, fn)
+ *    P.map.strict(array, fn)
+ *    P.map.strict.indexed(array, fn)
+ * @example
+ *    P.map([1, 2, 3], x => x * 2) // => [2, 4, 6], typed number[]
+ *    P.map.indexed([0, 0, 0], (x, i) => i) // => [0, 1, 2], typed number[]
+ *    P.map.strict([0, 0] as const, x => x + 1) // => [1, 1], typed [number, number]
+ *    P.map.strict.indexed([0, 0] as const, (x, i) => x + i) // => [0, 1], typed [number, number]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @strict
+ * @category Array
+ */
+declare function map<T, K>(array: ReadonlyArray<T>, fn: Pred<T, K>): Array<K>;
+/**
+ * Map each value of an object using a defined callback function.
+ * @param fn the function mapper
+ * @signature
+ *    P.map(fn)(array)
+ *    P.map.indexed(fn)(array)
+ * @example
+ *    P.pipe([0, 1, 2], P.map(x => x * 2)) // => [0, 2, 4]
+ *    P.pipe([0, 0, 0], P.map.indexed((x, i) => i)) // => [0, 1, 2]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function map<T, K>(fn: Pred<T, K>): (array: ReadonlyArray<T>) => Array<K>;
+declare namespace map {
+    function indexed<T, K>(array: ReadonlyArray<T>, fn: PredIndexed<T, K>): Array<K>;
+    function indexed<T, K>(fn: PredIndexed<T, K>): (array: ReadonlyArray<T>) => Array<K>;
+    const lazy: <T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<K>;
+    const lazyIndexed: (<T, K>(fn: PredIndexedOptional<T, K>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<K>) & {
+        indexed: true;
+    };
+    const strict: Strict$4;
+}
+
+/**
+ * Map each element of an array into an object using a defined callback function.
+ * @param array The array to map.
+ * @param fn The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.mapToObj(array, fn)
+ *    P.mapToObj.indexed(array, fn)
+ * @example
+ *    P.mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}
+ *    P.mapToObj.indexed([0, 0, 0], (x, i) => [i, i]) // => {0: 0, 1: 1, 2: 2}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function mapToObj<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T) => [K, V]): Record<K, V>;
+/**
+ * Map each element of an array into an object using a defined callback function.
+ * @param fn The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.mapToObj(fn)(array)
+ *    P.mapToObj.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.mapToObj(x => [String(x), x * 2])
+ *    ) // => {1: 2, 2: 4, 3: 6}
+ *    P.pipe(
+ *      [0, 0, 0],
+ *      P.mapToObj.indexed((x, i) => [i, i])
+ *    ) // => {0: 0, 1: 1, 2: 2}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function mapToObj<T, K extends keyof any, V>(fn: (element: T) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+declare namespace mapToObj {
+    function indexed<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): Record<K, V>;
+    function indexed<T, K extends keyof any, V>(fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+}
+
+/**
+ * Returns the max element using the provided predicate.
+ * @param fn the predicate
+ * @signature
+ *    P.maxBy(fn)(array)
+ *    P.maxBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.maxBy(x => x.a)
+ *    ) // { a: 5 }
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function maxBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => T | undefined;
+/**
+ * Returns the max element using the provided predicate.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.maxBy(array, fn)
+ *    P.maxBy.indexed(array, fn)
+ * @example
+ *    P.maxBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // { a: 5 }
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function maxBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): T | undefined;
+declare namespace maxBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
+}
+
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ * @param fn predicate function
+ * @signature
+ *   P.meanBy(fn)(array)
+ *   P.meanBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.meanBy(x => x.a)
+ *    ) // 3
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function meanBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ * @param items the array
+ * @param fn predicate function
+ * @signature
+ *   P.meanBy(array, fn)
+ *   P.meanBy.indexed(array, fn)
+ * @example
+ *    P.meanBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // 3
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function meanBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): number;
+declare namespace meanBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): number;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => number;
+}
+
+/**
+ * Merges a list of objects into a single object.
+ * @param array the array of objects
+ * @signature
+ *    P.mergeAll(objects)
+ * @example
+ *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }
+ * @category Array
+ */
+declare function mergeAll<A>(array: readonly [A]): A;
+declare function mergeAll<A, B>(array: readonly [A, B]): A & B;
+declare function mergeAll<A, B, C>(array: readonly [A, B, C]): A & B & C;
+declare function mergeAll<A, B, C, D>(array: readonly [A, B, C, D]): A & B & C & D;
+declare function mergeAll<A, B, C, D, E>(array: [A, B, C, D, E]): A & B & C & D & E;
+declare function mergeAll(array: ReadonlyArray<object>): object;
+
+/**
+ * Returns the min element using the provided predicate.
+ * @param fn the predicate
+ * @signature
+ *    P.minBy(fn)(array)
+ *    P.minBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.minBy(x => x.a)
+ *    ) // { a: 1 }
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function minBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => T | undefined;
+/**
+ * Returns the min element using the provided predicate.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.minBy(array, fn)
+ *    P.minBy.indexed(array, fn)
+ * @example
+ *    P.minBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // { a: 1 }
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function minBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): T | undefined;
+declare namespace minBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => T | undefined;
+}
+
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
+ * @param items the items to split
+ * @param predicate a type guard function to invoke on every item
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(array, fn)
+ * @example
+ *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function partition<T, S extends T>(items: ReadonlyArray<T>, predicate: (item: T) => item is S): [Array<S>, Array<Exclude<T, S>>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
+ * @param items the items to split
+ * @param predicate the function invoked per iteration
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(array, fn)
+ * @example
+ *    P.partition(['one', 'two', 'forty two'], x => x.length === 3) // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function partition<T>(items: ReadonlyArray<T>, predicate: (item: T) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` type guard passes, and the second one containing the rest.
+ * @param predicate the grouping function
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(fn)(array)
+ * @example
+ *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function partition<T, S extends T>(predicate: (item: T) => item is S): (array: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the `predicate` function matches, and the second one containing the rest.
+ * @param predicate the grouping function
+ * @returns the array of grouped elements.
+ * @signature
+ *    P.partition(fn)(array)
+ * @example
+ *    P.pipe(['one', 'two', 'forty two'], P.partition(x => x.length === 3)) // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function partition<T>(predicate: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+declare namespace partition {
+    function indexed<T>(array: ReadonlyArray<T>, predicate: PredIndexed<T, boolean>): [Array<T>, Array<T>];
+    function indexed<T>(predicate: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+}
+
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ * @param start the start number
+ * @param end the end number
+ * @signature range(start, end)
+ * @example
+ *    P.range(1, 5) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(start: number, end: number): Array<number>;
+/**
+ * Returns a list of numbers from `start` (inclusive) to `end` (exclusive).
+ * @param end the end number
+ * @signature range(end)(start)
+ * @example
+ *    P.range(5)(1) // => [1, 2, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function range(end: number): (start: number) => Array<number>;
+
+/**
+ * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+ * @param array the array to reduce
+ * @param fn the callback function
+ * @param initialValue the initial value to use as an accumulator value in the callback function
+ * @signature
+ *    P.reduce(items, fn, initialValue)
+ *    P.reduce.indexed(items, fn, initialValue)
+ * @example
+ *    P.reduce([1, 2, 3, 4, 5], (acc, x) => acc + x, 100) // => 115
+ *    P.reduce.indexed([1, 2, 3, 4, 5], (acc, x, i, array) => acc + x, 100) // => 115
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function reduce<T, K>(items: ReadonlyArray<T>, fn: (acc: K, item: T) => K, initialValue: K): K;
+/**
+ * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+ * @param fn the callback function
+ * @param initialValue the initial value to use as an accumulator value in the callback function
+ * @signature
+ *    P.reduce(fn, initialValue)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce((acc, x) => acc + x, 100)) // => 115
+ *    P.pipe([1, 2, 3, 4, 5], P.reduce.indexed((acc, x, i, array) => acc + x, 100)) // => 115
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function reduce<T, K>(fn: (acc: K, item: T) => K, initialValue: K): (items: ReadonlyArray<T>) => K;
+declare namespace reduce {
+    function indexed<T, K>(array: ReadonlyArray<T>, fn: (acc: K, item: T, index: number, items: Array<T>) => K, initialValue: K): K;
+    function indexed<T, K>(fn: (acc: K, item: T, index: number, items: Array<T>) => K, initialValue: K): (array: ReadonlyArray<T>) => K;
+}
+
+/**
+ * Reject the elements of an array that meet the condition specified in a callback function.
+ * @param items The array to reject.
+ * @param fn the callback function.
+ * @signature
+ *    P.reject(array, fn)
+ *    P.reject.indexed(array, fn)
+ * @example
+ *    P.reject([1, 2, 3], x => x % 2 === 0) // => [1, 3]
+ *    P.reject.indexed([1, 2, 3], (x, i, array) => x % 2 === 0) // => [1, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function reject<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): Array<T>;
+/**
+ * Reject the elements of an array that meet the condition specified in a callback function.
+ * @param items The array to reject.
+ * @param fn the callback function.
+ * @signature
+ *    P.reject(array, fn)
+ *    P.reject.indexed(array, fn)
+ * @example
+ *    P.reject([1, 2, 3], x => x % 2 === 0) // => [1, 3]
+ *    P.reject.indexed([1, 2, 3], (x, i, array) => x % 2 === 0) // => [1, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+declare function reject<T>(fn: Pred<T, boolean>): (items: ReadonlyArray<T>) => Array<T>;
+declare namespace reject {
+    function indexed<T, K>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): Array<K>;
+    function indexed<T, K>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => Array<K>;
+    const lazy: <T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => LazyResult<T>) & {
+        indexed: true;
+    };
+}
+
+type Reverse<T extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown> = []> = ReturnType<T extends IsNoTuple<T> ? () => [...T, ...R] : T extends readonly [infer F, ...infer L] ? () => Reverse<L, [F, ...R]> : () => R>;
+type IsNoTuple<T> = T extends readonly [unknown, ...Array<unknown>] ? never : T;
+/**
+ * Reverses array.
+ * @param array the array
+ * @signature
+ *    P.reverse(arr);
+ * @example
+ *    P.reverse([1, 2, 3]) // [3, 2, 1]
+ * @dataFirst
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(array: T): Reverse<T>;
+/**
+ * Reverses array.
+ * @param array the array
+ * @signature
+ *    P.reverse()(array);
+ * @example
+ *    P.reverse()([1, 2, 3]) // [3, 2, 1]
+ * @dataLast
+ * @category Array
+ */
+declare function reverse<T extends ReadonlyArray<unknown>>(): (array: T) => Reverse<T>;
+
+type Sampled<T extends IterableContainer, N extends number> = number extends N ? SampledGeneric<T> : undefined extends T[N] ? T : SampledLiteral<T, N>;
+type SampledGeneric<T extends IterableContainer> = T[number] extends never ? T : T extends readonly [infer First, ...infer Rest] ? [First, ...SampledGeneric<Rest>] | SampledGeneric<Rest> : Array<T[number]>;
+type SampledLiteral<T extends IterableContainer, N extends number, Iteration extends Array<unknown> = []> = Iteration['length'] extends N ? [] : T extends readonly [infer First, ...infer Tail] ? [
+    First | Tail[number],
+    ...SampledLiteral<Tail, N, [unknown, ...Iteration]>
+] : T extends readonly [...infer Head, infer Last] ? [...SampledLiteral<Head, N, [unknown, ...Iteration]>, Last] : [T[number], ...SampledLiteral<T, N, [unknown, ...Iteration]>] | SampledLiteral<T, N, [unknown, ...Iteration]>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param array the array
+ * @param sampleSize the number of elements to take
+ * @signature
+ *    P.sample(array, sampleSize)
+ * @example
+ *    P.sample(["hello", "world"], 1); // => ["hello"] // typed string[]
+ *    P.sample(["hello", "world"] as const, 1); // => ["world"] // typed ["hello" | "world"]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+declare function sample<T extends IterableContainer, N extends number = number>(data: T, sampleSize: N): Sampled<T, N>;
+/**
+ * Returns a random subset of size `sampleSize` from `array`.
+ *
+ * Maintains and infers most of the typing information that could be passed
+ * along to the output. This means that when using tuples, the output will be
+ * a tuple too, and when using literals, those literals would be preserved.
+ *
+ * The items in the result are kept in the same order as they are in the input.
+ * If you need to get a shuffled response you can pipe the shuffle function
+ * after this one.
+ *
+ * @param array the array
+ * @param sampleSize the number of elements to take
+ * @signature
+ *    P.sample(sampleSize)(array)
+ * @example
+ *    P.sample(1)(["hello", "world"]); // => ["hello"] // typed string[]
+ *    P.sample(1)(["hello", "world"] as const); // => ["world"] // typed ["hello" | "world"]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function sample<T extends IterableContainer, N extends number = number>(sampleSize: N): (data: T) => Sampled<T, N>;
+
+/**
+ * Shuffles the input array, returning a new array with the same elements in a random order.
+ * @param items the array to shuffle
+ * @signature
+ *    P.shuffle(array)
+ * @example
+ *    P.shuffle([4, 2, 7, 5]) // => [7, 5, 4, 2]
+ * @category Array
+ * @dataFirst
+ */
+declare function shuffle<T>(items: ReadonlyArray<T>): Array<T>;
+/**
+ * Shuffles the input array, returning a new array with the same elements in a random order.
+ * @signature
+ *    P.shuffle()(array)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.shuffle()) // => [7, 5, 4, 2]
+ * @category Array
+ * @dataLast
+ */
+declare function shuffle<T>(): (items: ReadonlyArray<T>) => Array<T>;
+
+interface Strict$3 {
+    <T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): Sorted<T>;
+    <T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => Sorted<T>;
+}
+type Sorted<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+/**
+ * Sorts an array. The comparator function should accept two values at a time and return a negative number if the first value is smaller, a positive number if it's larger, and zero if they are equal.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param items the array to sort
+ * @param cmp the comparator function
+ * @signature
+ *    P.sort(items, cmp)
+ *    P.sort.strict(items, cmp)
+ * @example
+ *    P.sort([4, 2, 7, 5], (a, b) => a - b) // => [2, 4, 5, 7] typed Array<number>
+ *    P.sort.strict([4, 2] as [number, number], (a, b) => a - b) // [2, 4] typed [number, number]
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+declare function sort<T>(items: ReadonlyArray<T>, cmp: (a: T, b: T) => number): Array<T>;
+/**
+ * Sorts an array. The comparator function should accept two values at a time and return a negative number if the first value is smaller, a positive number if it's larger, and zero if they are equal.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param cmp the comparator function
+ * @signature
+ *    P.sort(cmp)(items)
+ *    P.sort.strict(cmp)(items)
+ * @example
+ *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7] typed Array<number>
+ *    P.pipe([4, 2] as [number, number], P.sort.strict((a, b) => a - b)) // => [2, 4] typed [number, number]
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+declare function sort<T>(cmp: (a: T, b: T) => number): (items: ReadonlyArray<T>) => Array<T>;
+declare namespace sort {
+    const strict: Strict$3;
+}
+
+declare const ALL_DIRECTIONS: readonly ["asc", "desc"];
+type Direction = (typeof ALL_DIRECTIONS)[number];
+type ComparablePrimitive = number | string | boolean;
+type Comparable = ComparablePrimitive | {
+    valueOf(): ComparablePrimitive;
+};
+type SortProjection<T> = (x: T) => Comparable;
+type SortPair<T> = readonly [
+    projector: SortProjection<T>,
+    direction: Direction
+];
+type SortRule<T> = SortProjection<T> | SortPair<T>;
+interface Strict$2 {
+    <T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<SortRule<T[number]>>>): (array: T) => SortedBy<T>;
+    <T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<SortRule<T[number]>>>): SortedBy<T>;
+}
+type SortedBy<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+/**
+ * Sorts the list according to the supplied functions and directions.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * Directions are applied to functions in order and default to ascending if not specified.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param sortRule main sort rule
+ * @param additionalSortRules subsequent sort rules (these are only relevant when two items are equal based on the previous sort rule)
+ * @signature
+ *    P.sortBy(sortRule, ...additionalSortRules)(array)
+ *    P.sortBy.strict(sortRule, ...additionalSortRules)(array)
+ * @example
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      P.sortBy(x => x.a)
+ *    ) // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
+ *    P.pipe(
+ *      [{ a: 1 }, { a: 3 }] as const,
+ *      P.sortBy.strict(x => x.a)
+ *    ) // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+declare function sortBy<T>(...sortRules: Readonly<NonEmptyArray<SortRule<T>>>): (array: ReadonlyArray<T>) => Array<T>;
+/**
+ * Sorts the list according to the supplied functions and directions.
+ * Sorting is based on a native `sort` function. It's not guaranteed to be stable.
+ *
+ * Directions are applied to functions in order and default to ascending if not specified.
+ *
+ * If the input array is more complex (non-empty array, tuple, etc...) use the
+ * strict mode to maintain it's shape.
+ *
+ * @param array the array to sort
+ * @param sortRule main sort rule
+ * @param additionalSortRules subsequent sort rules (these are only relevant when two items are equal based on the previous sort rule)
+ * @signature
+ *    P.sortBy(array, sortRule, ...additionalSortRules)
+ *    P.sortBy.strict(array, sortRule, ...additionalSortRules)
+ * @example
+ *    P.sortBy(
+ *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
+ *      x => x.a
+ *    )
+ *    // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }] typed Array<{a:number}>
+ *
+ *    P.sortBy(
+ *     [
+ *       {color: 'red', weight: 2},
+ *       {color: 'blue', weight: 3},
+ *       {color: 'green', weight: 1},
+ *       {color: 'purple', weight: 1},
+ *     ],
+ *      [x => x.weight, 'asc'], x => x.color
+ *    )
+ *    // =>
+ *    //   {color: 'green', weight: 1},
+ *    //   {color: 'purple', weight: 1},
+ *    //   {color: 'red', weight: 2},
+ *    //   {color: 'blue', weight: 3},
+ *    // typed Array<{color: string, weight: number}>
+ *
+ *    P.sortBy.strict(
+ *      [{ a: 1 }, { a: 3 }] as const,
+ *      x => x.a
+ *    )
+ *    // => [{ a: 1 }, { a: 3 }] typed [{a: 1 | 3}, {a: 1 | 3}]
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+declare function sortBy<T>(array: ReadonlyArray<T>, ...sortRules: Readonly<NonEmptyArray<SortRule<T>>>): Array<T>;
+declare namespace sortBy {
+    const strict: Strict$2;
+}
+
+/**
+ * Splits a given array at a given index.
+ * @param array the array to split
+ * @param index the index to split at
+ * @signature
+ *    P.splitAt(array, index)
+ * @example
+ *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
+ *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
+/**
+ * Splits a given array at a given index.
+ * @param array the array to split
+ * @param index the index to split at
+ * @signature
+ *    P.splitAt(index)(array)
+ * @example
+ *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
+ *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+
+/**
+ * Splits a given array at the first index where the given predicate returns true.
+ * @param array the array to split
+ * @param fn the predicate
+ * @signature
+ *    P.splitWhen(array, fn)
+ * @example
+ *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitWhen<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a given array at an index where the given predicate returns true.
+ * @param fn the predicate
+ * @signature
+ *    P.splitWhen(fn)(array)
+ * @example
+ *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitWhen<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ * @param fn predicate function
+ * @signature
+ *   P.sumBy(fn)(array)
+ *   P.sumBy.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.sumBy(x => x.a)
+ *    ) // 9
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+declare function sumBy<T>(fn: (item: T) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ * @param items the array
+ * @param fn predicate function
+ * @signature
+ *   P.sumBy(array, fn)
+ *   P.sumBy.indexed(array, fn)
+ * @example
+ *    P.sumBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // 9
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+declare function sumBy<T>(items: ReadonlyArray<T>, fn: (item: T) => number): number;
+declare namespace sumBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, number>): number;
+    function indexed<T>(fn: PredIndexed<T, number>): (array: ReadonlyArray<T>) => number;
+}
+
+/**
+ * @link https://github.com/sindresorhus/type-fest/blob/main/source/is-equal.d.ts
+ */
+type isEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
+type Difference<A extends number, B extends number> = TupleOfLength<A> extends [
+    ...infer U,
+    ...TupleOfLength<B>
+] ? U['length'] : never;
+type isLessThan<A extends number, B extends number> = isEqual<A, B> extends true ? false : 0 extends A ? true : 0 extends B ? false : isLessThan<Difference<A, 1>, Difference<B, 1>>;
+type TupleOfLength<L extends number, T extends IterableContainer = []> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;
+type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends `-${string}` ? false : true;
+type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
+type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [
+    Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition,
+    ...SwapArrayInternal<Rest, Index1, Index2, [
+        unknown,
+        ...Position
+    ], Original>
+] : T;
+type SwapString<T extends string, K1 extends number, K2 extends number> = Joined<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
+type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends false ? Array<T[number]> : IsNonNegative<K2> extends false ? Array<T[number]> : isLessThan<K1, T['length']> extends false ? T : isLessThan<K2, T['length']> extends false ? T : SwapArrayInternal<T, K1, K2>;
+type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
+/**
+ * Swaps the positions of two elements in an array or string at the provided indices.
+ *
+ * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.
+ *
+ * If either index is out of bounds the result would be a shallow copy of the input, as-is.
+ *
+ * @param data the item to be manipulated. This can be an array, or a string.
+ * @param index1 the first index
+ * @param index2 the second index
+ *
+ * @signature
+ *   swapIndices(data, index1, index2)
+ *
+ * @example
+ *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']
+ *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['c', 'b', 'a']
+ *   swapIndices('abc', 0, 1) // => 'bac'
+ *
+ * @category Array
+ *
+ * @returns Returns the manipulated array or string.
+ *
+ * @dataFirst
+ */
+declare function swapIndices<T extends IterableContainer | string, K1 extends number, K2 extends number>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;
+/**
+ * @param index1 the first index
+ * @param index2 the second index
+ *
+ * @signature
+ *   swapIndices(index1, index2)(data)
+ *
+ * @example
+ *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']
+ *   swapIndices(0, -1)('abc') // => 'cba'
+ *
+ * @category Array
+ * @returns Returns the manipulated array or string.
+ * @dataLast
+ */
+declare function swapIndices<K1 extends number, K2 extends number>(index1: K1, index2: K2): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;
+
+/**
+ * Returns the first `n` elements of `array`.
+ * @param array the array
+ * @param n the number of elements to take
+ * @signature
+ *    P.take(array, n)
+ * @example
+ *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+declare function take<T>(array: ReadonlyArray<T>, n: number): Array<T>;
+/**
+ * Returns the first `n` elements of `array`.
+ * @param n the number of elements to take
+ * @signature
+ *    P.take(n)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function take<T>(n: number): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace take {
+    function lazy<T>(n: number): (value: T) => LazyResult<T>;
+}
+
+/**
+ * Returns elements from the array until predicate returns false.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.takeWhile(array, fn)
+ * @example
+ *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeWhile<T>(array: ReadonlyArray<T>, fn: (item: T) => boolean): Array<T>;
+/**
+ * Returns elements from the array until predicate returns false.
+ * @param fn the predicate
+ * @signature
+ *    P.takeWhile(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+declare function takeWhile<T>(fn: (item: T) => boolean): (array: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by reference using Set.
+ * Note: In `pipe`, use `uniq()` form instead of `uniq`. Otherwise, the inferred type is lost.
+ * @param array
+ * @signature
+ *    P.uniq(array)
+ * @example
+ *    P.uniq([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.uniq(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @pipeable
+ * @category Array
+ */
+declare function uniq<T>(array: ReadonlyArray<T>): Array<T>;
+declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace uniq {
+    function lazy(): (value: any) => LazyResult<any>;
+}
+
+declare function uniqBy<T, K>(array: ReadonlyArray<T>, transformer: (item: T) => K): Array<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original list transformed by a function.
+ * Elements are compared by reference using Set.
+ * @param array
+ * @signature
+ *    P.uniqBy(array, fn)
+ * @example
+ *    P.uniqBy(
+ *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],
+ *     (obj) => obj.n,
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @pipeable
+ * @category Array
+ */
+declare function uniqBy<T, K>(transformer: (item: T) => K): (array: ReadonlyArray<T>) => Array<T>;
+
+type IsEquals<T> = (a: T, b: T) => boolean;
+declare function _lazy<T>(isEquals: IsEquals<T>): (value: T, index?: number, array?: Array<T>) => LazyResult<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by custom comparator isEquals.
+ * @param array
+ * @param isEquals the comparator
+ * @signature
+ *    P.uniqWith(array, isEquals)
+ * @example
+ *    P.uniqWith(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ * @dataFirst
+ * @category Array
+ */
+declare function uniqWith<T>(array: ReadonlyArray<T>, isEquals: IsEquals<T>): Array<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original list.
+ * Elements are compared by custom comparator isEquals.
+ * @param isEquals the comparator
+ * @signature P.uniqWith(isEquals)(array)
+ * @example
+ *    P.uniqWith(P.equals)(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations
+ *      P.uniqWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @category Object
+ */
+declare function uniqWith<T>(isEquals: IsEquals<T>): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace uniqWith {
+    const lazy: typeof _lazy & {
+        indexed: true;
+    };
+}
+
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned items.
+ * The length of the returned list will match the shortest of the two inputs.
+ * @param first the first input list
+ * @param second the second input list
+ * @signature
+ *   P.zip(first, second)
+ * @example
+ *   P.zip([1, 2], ['a', 'b']) // => [1, 'a'], [2, 'b']
+ * @dataFirst
+ * @category Array
+ */
+declare function zip<F, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Array<[F, S]>;
+/**
+ * Creates a new list from two supplied lists by pairing up equally-positioned items.
+ * The length of the returned list will match the shortest of the two inputs.
+ * @param second the second input list
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']
+ * @dataLast
+ * @category Array
+ */
+declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
+
+/**
+ * Creates a new object from two supplied lists by pairing up equally-positioned items.
+ * Key/value pairing is truncated to the length of the shorter of the two lists
+ * @param first the first input list
+ * @param second the second input list
+ * @signature
+ *   P.zipObj(first, second)
+ * @example
+ *   P.zipObj(['a', 'b'], [1, 2]) // => {a: 1, b: 2}
+ * @dataFirst
+ * @category Array
+ */
+declare function zipObj<F extends string | number | symbol, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Record<F, S>;
+/**
+ * Creates a new object from two supplied lists by pairing up equally-positioned items.
+ * Key/value pairing is truncated to the length of the shorter of the two lists
+ * @param second the second input list
+ * @signature
+ *   P.zipObj(second)(first)
+ * @example
+ *   P.zipObj([1, 2])(['a', 'b']) // => {a: 1, b: 2}
+ * @dataLast
+ * @category Array
+ */
+declare function zipObj<S>(second: ReadonlyArray<S>): <F extends string | number | symbol>(first: ReadonlyArray<F>) => Record<F, S>;
+
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param first the first input list
+ * @param second the second input list
+ * @param fn the function applied to each position of the list
+ * @signature
+ *   P.zipWith(first, second, fn)
+ * @example
+ *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
+ * @dataFirst
+ * @category Array
+ */
+declare function zipWith<F, S, R>(first: Array<F>, second: Array<S>, fn: (f: F, s: S) => R): Array<R>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param fn the function applied to each position of the list
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a, b) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @category Array
+ */
+declare function zipWith<F, S, R>(fn: (f: F, s: S) => R): (first: Array<F>, second: Array<S>) => Array<R>;
+/**
+ * Creates a new list from two supplied lists by calling the supplied function
+ * with the same-positioned element from each list.
+ * @param fn the function applied to each position of the list
+ * @param second the second input list
+ * @signature
+ *   P.zipWith(fn)(first, second)
+ * @example
+ *   P.zipWith((a, b) => a + b, ['a', 'b', 'c'])(['1', '2', '3']) // => ['1a', '2b', '3c']
+ * @dataLast
+ * @category Array
+ */
+declare function zipWith<F, S, R>(fn: (f: F, s: S) => R, second: Array<S>): (first: Array<F>) => Array<R>;
+
+/**
+ * Creates a data-last pipe function. First function must be always annotated. Other functions are automatically inferred.
+ * @signature
+ *    P.createPipe(op1, op2, op3)(data);
+ * @example
+ *    P.createPipe(
+ *      (x: number) => x * 2,
+ *      x => x * 3
+ *    )(1) // => 6
+ * @category Function
+ */
+declare function createPipe<A, B>(op1: (input: A) => B): (value: A) => B;
+declare function createPipe<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
+declare function createPipe<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
+declare function createPipe<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
+declare function createPipe<A, B, C, D, E, F>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): (value: A) => F;
+declare function createPipe<A, B, C, D, E, F, G>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): (value: A) => G;
+declare function createPipe<A, B, C, D, E, F, G, H>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): (value: A) => H;
+
+/**
+ * A function that always returns the param passed to it
+ * @signature
+ *    P.identity(data)
+ * @example
+ *    P.identity('foo') // => 'foo'
+ * @category Function
+ */
+declare function identity<T>(value: T): T;
+
+/**
+ * A function that returns always `undefined`.
+ * @signature
+ *    P.noop()
+ * @example
+ *    onSomething(P.noop)
+ * @category Function
+ */
+declare function noop(): undefined;
+
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
+ * @param fn the function to wrap
+ * @signature P.once(fn)
+ * @example
+ * const initialize = P.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ * @category Function
+ */
+declare function once<T>(fn: () => T): () => T;
+
+/**
+ * Perform left-to-right function composition.
+ * @param value The initial value.
+ * @param operations the list of operations to apply.
+ * @signature P.pipe(data, op1, op2, op3)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3, 4],
+ *      P.map(x => x * 2),
+ *      arr => [arr[0] + arr[1], arr[2] + arr[3]],
+ *    ) // => [6, 14]
+ *
+ *
+ * @dataFirst
+ * @category Function
+ */
+declare function pipe<A, B>(value: A, op1: (input: A) => B): B;
+declare function pipe<A, B, C>(value: A, op1: (input: A) => B, op2: (input: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I, op9: (input: I) => J): J;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K): K;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L): L;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M): M;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N): N;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O): O;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O, op15: (input: O) => P): P;
+
+/**
+ * Creates a function with `data-first` and `data-last` signatures.
+ *
+ * `purry` is a dynamic function and it's not type safe. It should be wrapped by a function that have proper typings.
+ * Refer to the example below for correct usage.
+ *
+ * @param fn the function to purry.
+ * @param args the arguments
+ * @signature P.purry(fn, arguments);
+ * @exampleRaw
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex() {
+ *      return P.purry(_findIndex, arguments);
+ *    }
+ * @category Function
+ */
+declare function purry(fn: any, args: IArguments | ReadonlyArray<any>, lazy?: any): any;
+
+type DefinitelyArray<T> = Extract<T, Array<any> | ReadonlyArray<any>> extends never ? ReadonlyArray<unknown> : Extract<T, Array<any> | ReadonlyArray<any>>;
+/**
+ * A function that checks if the passed parameter is an Array and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isArray(data)
+ * @returns true if the passed input is an Array, false otherwise
+ * @example
+ *    P.isArray([5]) //=> true
+ *    P.isArray([]) //=> true
+ *    P.isArray('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isArray<T>(data: T | ReadonlyArray<unknown>): data is DefinitelyArray<T>;
+
+type DefinitelyBoolean<T> = Extract<T, boolean> extends never ? boolean : Extract<T, boolean> extends any ? boolean : Extract<T, number>;
+/**
+ * A function that checks if the passed parameter is a boolean and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isBoolean(data)
+ * @returns true if the passed input is a boolean, false otherwise
+ * @example
+ *    P.isBoolean(true) //=> true
+ *    P.isBoolean(false) //=> true
+ *    P.isBoolean('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isBoolean<T>(data: T | boolean): data is DefinitelyBoolean<T>;
+
+/**
+ * A function that checks if the passed parameter is a Date and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isDate(data)
+ * @returns true if the passed input is a Date, false otherwise
+ * @example
+ *    P.isDate(new Date()) //=> true
+ *    P.isDate('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isDate(data: unknown): data is Date;
+
+/**
+ * A function that checks if the passed parameter is defined and narrows its type accordingly.
+ * To test specifically for `undefined` (and not `null`) use the strict variant of this function.
+ * @param data the variable to check
+ * @signature
+ *    P.isDefined(data)
+ *    P.isDefined.strict(data)
+ * @returns true if the passed input is defined, false otherwise
+ * @example
+ *    P.isDefined('string') //=> true
+ *    P.isDefined(null) //=> false
+ *    P.isDefined(undefined) //=> false
+ *    P.isDefined.strict(null) //=> true
+ *    P.isDefined.strict(undefined) //=> false
+ * @category Guard
+ * @strict
+ */
+declare function isDefined<T>(data: T): data is NonNullable<T>;
+declare namespace isDefined {
+    function strict<T>(data: T | undefined): data is T;
+}
+
+/**
+ * A function that checks if the passed parameter is empty
+ * @param data the variable to check
+ * @signature
+ *    P.isEmpty(data)
+ * @returns true if the passed input is empty, false otherwise
+ * @example
+ *    P.isEmpty('') //=> true
+ *    P.isEmpty([]) //=> true
+ *    P.isEmpty({}) //=> true
+ *    P.isEmpty('test') //=> false
+ *    P.isEmpty([1, 2, 3]) //=> false
+ *    P.isEmpty({ length: 0 }) //=> false
+ * @category Function
+ */
+declare function isEmpty(data: string): data is '';
+declare function isEmpty(data: ReadonlyArray<unknown> | []): data is [];
+declare function isEmpty<T extends Readonly<Record<PropertyKey, unknown>>>(data: T): data is Record<keyof T, never>;
+
+type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
+/**
+ * A function that checks if the passed parameter is an Error and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isError(data)
+ * @returns true if the passed input is an Error, false otherwise
+ * @example
+ *    P.isError(new Error('message')) //=> true
+ *    P.isError('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isError<T>(data: T | Error): data is DefinitelyError<T>;
+
+type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Extract<T, Function>;
+/**
+ * A function that checks if the passed parameter is a Function and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isFunction(data)
+ * @returns true if the passed input is a Function, false otherwise
+ * @example
+ *    P.isFunction(() => {}) //=> true
+ *    P.isFunction('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isFunction<T>(data: T | Function): data is DefinitelyFunction<T>;
+
+/**
+ * A function that checks if the passed parameter is Nil (null or undefined) and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isNil(data)
+ * @returns true if the passed input is Nil (null or undefined), false otherwise
+ * @example
+ *    P.isNil(undefined) //=> true
+ *    P.isNil(null) //=> true
+ *    P.isNil('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isNil<T>(data: T): data is Extract<T, null | undefined>;
+
+/**
+ * A function that checks if the passed parameter is not `null` and narrows its type accordingly.
+ * Notice that `undefined` is not null!
+ * @param data the variable to check
+ * @signature
+ *    P.isNonNull(data)
+ * @returns true if the passed input is defined, false otherwise
+ * @example
+ *    P.isNonNull('string') //=> true
+ *    P.isNonNull(null) //=> false
+ *    P.isNonNull(undefined) //=> true
+ * @category Guard
+ */
+declare function isNonNull<T>(data: T | null): data is T;
+
+/**
+ * A function that takes a guard function as predicate and returns a guard that negates it
+ * @param predicate the guard function to negate
+ * @signature
+ *    P.isNot(P.isTruthy)(data)
+ * @returns function A guard function
+ * @example
+ *    P.isNot(P.isTruthy)(false) //=> true
+ *    P.isNot(P.isTruthy)(true) //=> false
+ * @dataLast
+ * @category Guard
+ */
+declare function isNot<T, S extends T>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
+declare function isNot<T>(predicate: (data: T) => any): (data: T) => boolean;
+
+type DefinitelyNumber<T> = Extract<T, number> extends never ? number : Extract<T, number> extends any ? number : Extract<T, number>;
+/**
+ * A function that checks if the passed parameter is a number and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    R.isNumber(data)
+ * @returns true if the passed input is a number, false otherwise
+ * @example
+ *    R.isNumber(1) //=> true
+ *    R.isNumber('notANumber') //=> false
+ * @category Guard
+ */
+declare function isNumber<T>(data: T | number): data is DefinitelyNumber<T>;
+
+type DefinitelyObject<T> = Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>> extends never ? Record<string, unknown> : Exclude<Extract<T, object>, Array<any> | Function | ReadonlyArray<any>>;
+/**
+ * A function that checks if the passed parameter is of type Object and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isObject(data)
+ * @returns true if the passed input is an Object, Promise, Date or Error, false otherwise
+ * @example
+ *    P.isObject({}) //=> true
+ *    P.isObject(Promise.resolve("something")) //=> true
+ *    P.isObject(new Date()) //=> true
+ *    P.isObject(new Error("error")) //=> true
+ *    P.isObject('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isObject<T>(data: T | object): data is DefinitelyObject<T>;
+
+/**
+ * A function that checks if the passed parameter is a Promise and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isPromise(data)
+ * @returns true if the passed input is a Promise, false otherwise
+ * @example
+ *    P.isPromise(Promise.resolve(5)) //=> true
+ *    P.isPromise(Promise.reject(5)) //=> true
+ *    P.isPromise('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
+
+type DefinitelyString<T> = Extract<T, string> extends never ? string : Extract<T, string> extends any ? string : Extract<T, string>;
+/**
+ * A function that checks if the passed parameter is a string and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isString(data)
+ * @returns true if the passed input is a string, false otherwise
+ * @example
+ *    P.isString('string') //=> true
+ *    P.isString(1) //=> false
+ * @category Guard
+ */
+declare function isString<T>(data: T | string): data is DefinitelyString<T>;
+
+/**
+ * A function that checks if the passed parameter is truthy and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isTruthy(data)
+ * @returns true if the passed input is truthy, false otherwise
+ * @example
+ *    P.isTruthy('somethingElse') //=> true
+ *    P.isTruthy(null) //=> false
+ *    P.isTruthy(undefined) //=> false
+ *    P.isTruthy(false) //=> false
+ *    P.isTruthy(0) //=> false
+ *    P.isTruthy('') //=> false
+ * @category Guard
+ */
+declare function isTruthy<T>(data: T): data is Exclude<T, null | undefined | false | '' | 0>;
+
+declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+/**
+ * Increase string a value with unit
+ *
+ */
+declare function increaseWithUnit({ target, delta }: {
+    target: string | number;
+    delta: number;
+}): string | number;
+declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
+declare function sleep(timeout: number): Promise<void>;
+
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ * @param value the number
+ * @param limits the bounds limits
+ * @signature
+ *    P.clamp(value, { min, max });
+ * @example
+ *    clamp(10, { min: 20 }) // => 20
+ *    clamp(10, { max: 5 }) // => 5
+ *    clamp(10, { max: 20, min: 5 }) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function clamp(value: number, limits: {
+    min?: number;
+    max?: number;
+}): number;
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ * @param value the number
+ * @param limits the bounds limits
+ * @signature
+ *    P.clamp({ min, max })(value);
+ * @example
+ *    clamp({ min: 20 })(10) // => 20
+ *    clamp({ max: 5 })(10) // => 5
+ *    clamp({ max: 20, min: 5 })(10) // => 10
+ * @dataLast
+ * @category Number
+ */
+declare function clamp(limits: {
+    min?: number;
+    max?: number;
+}): (value: number) => number;
+
+/**
+ * Add a new property to an object.
+ * @param obj the target object
+ * @param prop the property name
+ * @param value the property value
+ * @signature
+ *  P.addProp(obj, prop, value)
+ * @example
+ *  P.addProp({firstName: 'john'}, 'lastName', 'doe') // => {firstName: 'john', lastName: 'doe'}
+ * @dataFirst
+ * @category Object
+ */
+declare function addProp<T extends Record<PropertyKey, any>, K extends string, V>(obj: T, prop: K, value: V): T & {
+    [x in K]: V;
+};
+/**
+ * Add a new property to an object.
+ * @param prop the property name
+ * @param value the property value
+ * @signature
+ *  P.addProp(prop, value)(obj)
+ * @example
+ *  P.addProp('lastName', 'doe')({firstName: 'john'}) // => {firstName: 'john', lastName: 'doe'}
+ * @dataLast
+ * @category Object
+ */
+declare function addProp<T extends Record<PropertyKey, any>, K extends string, V>(prop: K, value: V): (obj: T) => T & {
+    [x in K]: V;
+};
+
+/**
+ * Creates a deep copy of the value. Supported types: `Array`, `Object`, `Number`, `String`, `Boolean`, `Date`, `RegExp`. Functions are assigned by reference rather than copied.
+ * @param value the object to clone
+ * @category Object
+ * @signature P.clone(value)
+ * @example P.clone({foo: 'bar'}) // {foo: 'bar'}
+ */
+declare function clone<T>(value: T): T;
+
+/**
+ * Returns true if its arguments are equivalent, false otherwise.
+ * NOTE: Doesn't handle cyclical data structures.
+ * @param a the first object to compare
+ * @param b the second object to compare
+ * @signature
+ *    P.equals(a, b)
+ * @example
+ *    P.equals(1, 1) //=> true
+ *    P.equals(1, '1') //=> false
+ *    P.equals([1, 2, 3], [1, 2, 3]) //=> true
+ * @dataFirst
+ * @category Object
+ */
+declare function equals(a: any, b: any): boolean;
+/**
+ * Returns true if its arguments are equivalent, false otherwise.
+ * NOTE: Doesn't handle cyclical data structures.
+ * @param a the first object to compare
+ * @param b the second object to compare
+ * @signature
+ *    P.equals(b)(a)
+ * @example
+ *    P.equals(1)(1) //=> true
+ *    P.equals('1')(1) //=> false
+ *    P.equals([1, 2, 3])([1, 2, 3]) //=> true
+ * @dataLast
+ * @category Object
+ */
+declare function equals(a: any): (b: any) => boolean;
+
+type IndexedIteratee<T extends Record<PropertyKey, any>, K extends keyof T> = (value: T[K], key: K, obj: T) => void;
+type UnindexedIteratee<T extends Record<PropertyKey, any>> = (value: T[keyof T]) => void;
+/**
+ * Iterate an object using a defined callback function. The original object is returned.
+ * @param object The object.
+ * @param fn The callback function.
+ * @returns The original object
+ * @signature
+ *    P.forEachObj(object, fn)
+ * @example
+ *    P.forEachObj({a: 1}, (val) => {
+ *      console.log(`${val}`)
+ *    }) // "1"
+ *    P.forEachObj.indexed({a: 1}, (val, key, obj) => {
+ *      console.log(`${key}: ${val}`)
+ *    }) // "a: 1"
+ * @dataFirst
+ * @category Object
+ */
+declare function forEachObj<T extends Record<PropertyKey, any>>(object: T, fn: UnindexedIteratee<T>): T;
+/**
+ * Iterate an object using a defined callback function. The original object is returned.
+ * @param fn The callback function.
+ * @signature
+ *    P.forEachObj(fn)(object)
+ * @example
+ *  P.pipe(
+ *      {a: 1},
+ *      P.forEachObj((val) => console.log(`${val}`))
+ *    ) // "1"
+ *    P.pipe(
+ *      {a: 1},
+ *      P.forEachObj.indexed((val, key) => console.log(`${key}: ${val}`))
+ *    ) // "a: 1"
+ * @dataLast
+ * @category Object
+ */
+declare function forEachObj<T extends Record<PropertyKey, any>>(fn: UnindexedIteratee<T>): (object: T) => T;
+declare namespace forEachObj {
+    function indexed<T extends Record<PropertyKey, any>>(object: T, fn: IndexedIteratee<T, keyof T>): T;
+    function indexed<T extends Record<PropertyKey, any>>(fn: IndexedIteratee<T, keyof T>): (object: T) => T;
+}
+
+type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [
+    key: Key,
+    value: Value
+];
+type Strict$1 = <Entries extends IterableContainer<Entry>>(entries: Entries) => StrictOut<Entries>;
+type StrictOut<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromPairsTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromPairsTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromPairsArray<Entries> : 'ERROR: Entries array-like could not be infered';
+type FromPairsTuple<E, Rest> = E extends Entry ? Record<E[0], E[1]> & StrictOut<Rest> : 'ERROR: Array-like contains a non-entry element';
+type FromPairsArray<Entries extends IterableContainer<Entry>> = string extends AllKeys$1<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys$1<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys$1<Entries> ? Record<symbol, Entries[number][1]> : FromPairsArrayWithLiteralKeys<Entries>;
+type FromPairsArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = {
+    [K in AllKeys$1<Entries>]?: ValueForKey<Entries, K>;
+};
+type AllKeys$1<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
+type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ * @param pairs the list of input tuples
+ * @signature
+ *   P.fromPairs(tuples)
+ *   P.fromPairs.strict(tuples)
+ * @example
+ *   P.fromPairs([['a', 'b'], ['c', 'd']]) // => {a: 'b', c: 'd'} (type: Record<string, string>)
+ *   P.fromPairs.strict(['a', 1] as const) // => {a: 1} (type: {a: 1})
+ * @category Object
+ * @strict
+ */
+declare function fromPairs<V>(pairs: ReadonlyArray<Entry<number, V>>): Record<number, V>;
+declare function fromPairs<V>(pairs: ReadonlyArray<Entry<string, V>>): Record<string, V>;
+declare namespace fromPairs {
+    const strict: Strict$1;
+}
+
+type Inverted<T extends object> = T[keyof T] extends PropertyKey ? Record<T[keyof T], keyof T> : never;
+/**
+ * Returns an object whose keys are values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ * @param object the object
+ * @signature
+ *    P.invert(object)
+ * @example
+ *    P.invert({ a: "d", b: "e", c: "f" }) // => { d: "a", e: "b", f: "c" }
+ * @dataFirst
+ * @category object
+ * @pipeable
+ */
+declare function invert<T extends object>(object: T): Inverted<T>;
+/**
+ * Returns an object whose keys are values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ * @param object the object
+ * @signature
+ *    P.invert()(object)
+ * @example
+ *    P.pipe({ a: "d", b: "e", c: "f" }, P.invert()); // => { d: "a", e: "b", f: "c" }
+ * @dataLast
+ * @category object
+ * @pipeable
+ */
+declare function invert<T extends object>(): (object: T) => Inverted<T>;
+
+/**
+ * Returns a new array containing the keys of the array or object.
+ * @param source Either an array or an object
+ * @signature
+ *    P.keys(source)
+ *    P.keys.strict(source)
+ * @example
+ *    P.keys(['x', 'y', 'z']) // => ['0', '1', '2']
+ *    P.keys({ a: 'x', b: 'y', c: 'z' }) // => ['a', 'b', 'c']
+ *    P.pipe(
+ *      { a: 'x', b: 'y', c: 'z' },
+ *      P.keys,
+ *      P.first
+ *    ) // => 'a'
+ *    P.keys.strict({ a: 'x', b: 'y', 5: 'z' } as const ) // => ['a', 'b', '5'], typed Array<'a' | 'b' | '5'>
+ * @pipeable
+ * @strict
+ * @category Object
+ */
+
+type Strict = <T extends object>(source: T) => Keys<T>;
+type Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys$1<T>;
+type ArrayKeys<T extends IterableContainer> = {
+    -readonly [Index in keyof T]: Index extends string | number ? `${IsIndexAfterSpread<T, Index> extends true ? number : Index}` : never;
+};
+type IsIndexAfterSpread<T extends IterableContainer, Index extends string | number> = IndicesAfterSpread<T> extends never ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
+type IndicesAfterSpread<T extends ReadonlyArray<unknown> | [], Iterations extends ReadonlyArray<unknown> = []> = T[number] extends never ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
+type ObjectKeys$1<T> = T extends Record<PropertyKey, never> ? [] : Array<`${Exclude<keyof T, symbol>}`>;
+declare function keys(source: Record<PropertyKey, unknown> | ArrayLike<unknown>): Array<string>;
+declare namespace keys {
+    const strict: Strict;
+}
+
+/**
+ * Maps keys of `object` and keeps the same values.
+ * @param object the object to map
+ * @param fn the mapping function
+ * @signature
+ *    P.mapKeys(object, fn)
+ * @example
+ *    P.mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mapKeys<T, S extends keyof any>(object: T, fn: (key: keyof T, value: T[keyof T]) => S): Record<S, T[keyof T]>;
+/**
+ * Maps keys of `object` and keeps the same values.
+ * @param fn the mapping function
+ * @signature
+ *    P.mapKeys(fn)(object)
+ * @example
+ *    P.pipe({a: 1, b: 2}, P.mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mapKeys<T, S extends keyof any>(fn: (key: keyof T, value: T[keyof T]) => S): (object: T) => Record<S, T[keyof T]>;
+
+/**
+ * Maps values of `object` and keeps the same keys.
+ * @param object the object to map
+ * @param fn the mapping function
+ * @signature
+ *    P.mapValues(object, fn)
+ * @example
+ *    P.mapValues({a: 1, b: 2}, (value, key) => value + key) // => {a: '1a', b: '2b'}
+ * @dataFirst
+ * @category Object
+ */
+declare function mapValues<T extends Record<PropertyKey, any>, S>(object: T, fn: (value: T[keyof T], key: keyof T) => S): Record<keyof T, S>;
+/**
+ * Maps values of `object` and keeps the same keys.
+ * @param fn the mapping function
+ * @signature
+ *    P.mapValues(fn)(object)
+ * @example
+ *    P.pipe({a: 1, b: 2}, P.mapValues((value, key) => value + key)) // => {a: '1a', b: '2b'}
+ * @dataLast
+ * @category Object
+ */
+declare function mapValues<T extends Record<PropertyKey, any>, S>(fn: (value: T[keyof T], key: keyof T) => S): (object: T) => Record<keyof T, S>;
+
+/**
+ * Merges two objects. The same as `Object.assign`.
+ * `b` object will override properties of `a`.
+ * @param a the first object
+ * @param b the second object
+ * @signature
+ *    P.merge(a, b)
+ * @example
+ *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<A, B>(a: A, b: B): A & B;
+/**
+ * Merges two objects. The same as `Object.assign`. `b` object will override properties of `a`.
+ * @param b the second object
+ * @signature
+ *    P.merge(b)(a)
+ * @example
+ *    P.merge({ y: 10, z: 2 })({ x: 1, y: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<A, B>(b: B): (a: A) => A & B;
+
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ * @param data the object
+ * @param propNames the property names
+ * @signature
+ *    P.omit(obj, names);
+ * @example
+ *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
+ * @dataFirst
+ * @category Object
+ */
+declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ * @param data the object
+ * @param propNames the property names
+ * @signature
+ *    P.omit(names)(obj);
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
+ * @dataLast
+ * @category Object
+ */
+declare function omit<K extends PropertyKey>(propNames: ReadonlyArray<K>): <T extends object>(data: T) => Omit<T, K>;
+
+/**
+ * Returns a partial copy of an object omitting the keys matching predicate.
+ * @param object the target object
+ * @param fn the predicate
+ * @signature P.omitBy(object, fn)
+ * @example
+ *    P.omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}
+ * @dataFirst
+ * @category Object
+ */
+declare function omitBy<T>(object: T, fn: <K extends keyof T>(value: T[K], key: K) => boolean): T extends Record<keyof T, T[keyof T]> ? T : Partial<T>;
+/**
+ * Returns a partial copy of an object omitting the keys matching predicate.
+ * @param fn the predicate
+ * @signature P.omitBy(fn)(object)
+ * @example
+ *    P.omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}
+ * @dataLast
+ * @category Object
+ */
+declare function omitBy<T>(fn: <K extends keyof T>(value: T[K], key: K) => boolean): (object: T) => T extends Record<keyof T, T[keyof T]> ? T : Partial<T>;
+
+/**
+ * Given a union of indexable types `T`, we derive an indexable type
+ * containing all of the keys of each variant of `T`. If a key is
+ * present in multiple variants of `T`, then the corresponding type in
+ * `Pathable<T>` will be the intersection of all types for that key.
+ * @example
+ *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ *    type T2 = Pathable<{a?: {b: string}}
+ *    // {a: {b: string} | undefined}
+ *
+ *    type T3 = Pathable<{a: string} | number>
+ *    // {a: string}
+ *
+ *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ * This type lets us answer the questions:
+ * - Given some object of type `T`, what keys might this object have?
+ * - If this object did happen to have a particular key, what values
+ *   might that key have?
+ */
+type Pathable<T> = {
+    [K in AllKeys<T>]: TypesForKey<T, K>;
+};
+type AllKeys<T> = T extends infer I ? keyof I : never;
+type TypesForKey<T, K extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
+type StrictlyRequired<T> = {
+    [K in keyof T]-?: NonNullable<T[K]>;
+};
+/**
+ * Given some `A` which is a key of at least one variant of `T`, derive
+ * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
+ * null or undefined.
+ */
+type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
+/** All possible options after successfully reaching `T[A]` */
+type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
+/** As `PathValue1`, but for `T[A][B]` */
+type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
+/** As `Pathable1`, but for `T[A][B]` */
+type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
+/** As `PathValue1`, but for `T[A][B][C]` */
+type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
+ * @param object the target object
+ * @param path the path of the property to get
+ * @param defaultValue the default value
+ * @signature P.pathOr(object, array, defaultValue)
+ * @example
+ *    P.pathOr({x: 10}, ['y'], 2) // 2
+ *    P.pathOr({y: 10}, ['y'], 2) // 10
+ * @dataFirst
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
+ * @param object the target object
+ * @param path the path of the property to get
+ * @param defaultValue the default value
+ * @signature P.pathOr(array, defaultValue)(object)
+ * @example
+ *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
+ *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
+ * @dataLast
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
+
+/**
+ * Creates an object composed of the picked `object` properties.
+ * @param object the target object
+ * @param names the properties names
+ * @signature P.pick(object, [prop1, prop2])
+ * @example
+ *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }
+ * @dataFirst
+ * @category Object
+ */
+declare function pick<T extends object, K extends keyof T>(object: T, names: ReadonlyArray<K>): Pick<T, K>;
+/**
+ * Creates an object composed of the picked `object` properties.
+ * @param names the properties names
+ * @signature P.pick([prop1, prop2])(object)
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }
+ * @dataLast
+ * @category Object
+ */
+declare function pick<K extends PropertyKey>(names: ReadonlyArray<K>): <T extends Record<PropertyKey, any>>(object: T) => Pick<T, K>;
+
+/**
+ * Creates an object composed of the picked `object` properties.
+ * @param object the target object
+ * @param fn the predicate
+ * @signature P.pickBy(object, fn)
+ * @example
+ *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
+ * @dataFirst
+ * @category Object
+ */
+declare function pickBy<T>(object: T, fn: <K extends keyof T>(value: T[K], key: K) => boolean): T extends Record<keyof T, T[keyof T]> ? T : Partial<T>;
+/**
+ * Creates an object composed of the picked `object` properties.
+ * @param fn the predicate
+ * @signature P.pickBy(fn)(object)
+ * @example
+ *    P.pickBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {A: 3, B: 4}
+ * @dataLast
+ * @category Object
+ */
+declare function pickBy<T>(fn: <K extends keyof T>(value: T[K], key: K) => boolean): (object: T) => T extends Record<keyof T, T[keyof T]> ? T : Partial<T>;
+
+/**
+ * Gets the value of the given property.
+ * @param propName the property name
+ * @signature P.prop(prop)(object)
+ * @example
+ *    P.pipe({foo: 'bar'}, P.prop('foo')) // => 'bar'
+ * @dataLast
+ * @category Object
+ */
+declare function prop<T, K extends keyof T>(propName: K): ({ [propName]: value }: T) => T[K];
+
+/**
+ * Sets the `value` at `prop` of `object`.
+ * @param obj the target method
+ * @param prop the property name
+ * @param value the value to set
+ * @signature
+ *    P.set(obj, prop, value)
+ * @example
+ *    P.set({ a: 1 }, 'a', 2) // => { a: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function set<T, K extends keyof T>(obj: T, prop: K, value: T[K]): T;
+/**
+ * Sets the `value` at `prop` of `object`.
+ * @param prop the property name
+ * @param value the value to set
+ * @signature
+ *    P.set(prop, value)(obj)
+ * @example
+ *    P.pipe({ a: 1 }, P.set('a', 2)) // => { a: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function set<T, K extends keyof T>(prop: K, value: T[K]): (obj: T) => T;
+
+type Path<Obj, Prefix extends Array<PropertyKey> = []> = Obj extends Primitive ? Prefix : Obj extends Array<infer Item> ? Prefix | Path<Item, [...Prefix, number]> : Prefix | PathsOfObject<Obj, Prefix>;
+type PathsOfObject<Obj, Prefix extends Array<PropertyKey>> = {
+    [K in keyof Obj]: Path<Obj[K], [...Prefix, K]>;
+}[keyof Obj];
+type ValueAtPath<Obj, ObjPath extends Array<PropertyKey> = []> = ObjPath extends [] ? Obj : ObjPath extends [infer Head, ...infer Tail] ? Tail extends Array<PropertyKey> ? Head extends keyof Obj ? ValueAtPath<Obj[Head], Tail> : never : never : never;
+type SupportsValueAtPath<Obj, Path extends Array<PropertyKey>, Value> = Value extends ValueAtPath<Obj, Path> ? Obj : never;
+type Primitive = string | number | boolean | null | undefined | symbol;
+
+/**
+ * Copied from ts-toolbelt
+ * https://github.com/millsp/ts-toolbelt/blob/master/sources/Function/Narrow.ts
+ */
+/**
+ * Similar to [[Cast]] but with a custom fallback `Catch`. If it fails,
+ * it will enforce `Catch` instead of `A2`.
+ * @param A1 to check against
+ * @param A2 to try/test with
+ * @param Catch to fallback to if the test failed
+ * @returns `A1 | Catch`
+ * @example
+ * ```ts
+ * import {A} from 'ts-toolbelt'
+ *
+ * type test0 = A.Try<'42', string>          // '42'
+ * type test1 = A.Try<'42', number>          // never
+ * type test1 = A.Try<'42', number, 'tried'> // 'tried'
+ * ```
+ */
+type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch;
+/**
+ * Describes types that can be narrowed
+ */
+type Narrowable = string | number | bigint | boolean;
+/**
+ * @hidden
+ */
+type NarrowRaw<A> = (A extends [] ? [] : never) | (A extends Narrowable ? A : never) | {
+    [K in keyof A]: A[K] extends (...args: Array<any>) => any ? A[K] : NarrowRaw<A[K]>;
+};
+/**
+ * Prevent type widening on generic function parameters
+ * @param A to narrow
+ * @returns `A`
+ * @example
+ * ```ts
+ * import {F} from 'ts-toolbelt'
+ *
+ * declare function foo<A extends any[]>(x: F.Narrow<A>): A;
+ * declare function bar<A extends object>(x: F.Narrow<A>): A;
+ *
+ * const test0 = foo(['e', 2, true, {f: ['g', ['h']]}])
+ * // `A` inferred : ['e', 2, true, {f: ['g']}]
+ *
+ * const test1 = bar({a: 1, b: 'c', d: ['e', 2, true, {f: ['g']}]})
+ * // `A` inferred : {a: 1, b: 'c', d: ['e', 2, true, {f: ['g']}]}
+ * ```
+ */
+type Narrow<A> = Try<A, [], NarrowRaw<A>>;
+
+/**
+ * Sets the value at `path` of `object`. `path` can be an array or a path string.
+ * @param object the target method
+ * @param path the property name
+ * @param value the value to set
+ * @signature
+ *    P.setPath(obj, path, value)
+ * @example
+ *    P.setPath({ a: { b: 1 } }, ['a', 'b'], 2) // => { a: { b: 2 } }
+ * @dataFirst
+ * @category Object
+ */
+declare function setPath<T, TPath extends Array<PropertyKey> & Path<T>>(object: T, path: Narrow<TPath>, value: ValueAtPath<T, TPath>): T;
+/**
+ * Sets the value at `path` of `object`. `path` can be an array or a path string.
+ * @param obj the target method
+ * @param path the property name
+ * @param value the value to set
+ * @signature
+ *    P.setPath(obj, path, value)
+ * @example
+ *    P.pipe({ a: { b: 1 } }, P.setPath(['a', 'b'], 2)) // { a: { b: 2 } }
+ * @dataFirst
+ * @category Object
+ */
+declare function setPath<TPath extends Array<PropertyKey>, Value>(path: Narrow<TPath>, value: Value): <Obj>(object: SupportsValueAtPath<Obj, TPath, Value>) => Obj;
+declare function _setPath(object: any, path: Array<any>, defaultValue: any): any;
+
+type SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {
+    [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];
+};
+/**
+ * Swaps the positions of two properties in an object based on the provided keys.
+ *
+ * @param data the object to be manipulated
+ * @param key1 the first property key
+ * @param key2 the second property key
+ *
+ * @signature
+ *   swap(data, key1, key2)
+ *
+ * @returns Returns the manipulated object.
+ *
+ * @example
+ *   swap({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}
+ *
+ * @category Object
+ *
+ * @dataFirst
+ */
+declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;
+/**
+ * Swaps the positions of two properties in an object based on the provided keys.
+ *
+ * @param key1 the first property key
+ * @param key2 the second property key
+ *
+ * @signature
+ *   swap(key1, key2)(data)
+ *
+ * @example
+ *   swap('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}
+ *
+ * @returns Returns the manipulated object.
+ *
+ * @category Object
+ *
+ * @dataLast
+ */
+declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;
+
+type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+type ObjectValues<T extends Record<PropertyKey, unknown>> = Required<T>[ObjectKeys<T>];
+type ObjectEntry<T extends Record<PropertyKey, unknown>> = [
+    ObjectKeys<T>,
+    ObjectValues<T>
+];
+type ObjectEntries<T extends Record<PropertyKey, unknown>> = Array<ObjectEntry<T>>;
+/**
+ * Returns an array of key/values of the enumerable properties of an object.
+ * @param object
+ * @signature
+ *    P.toPairs(object)
+ *    P.toPairs.strict(object)
+ * @example
+ *    P.toPairs({ a: 1, b: 2, c: 3 }) // => [['a', 1], ['b', 2], ['c', 3]]
+ *    P.toPairs.strict({ a: 1 } as const) // => [['a', 1]] typed Array<['a', 1]>
+ * @strict
+ * @category Object
+ */
+declare function toPairs<T>(object: Record<string, T>): Array<[string, T]>;
+declare namespace toPairs {
+    function strict<T extends Record<PropertyKey, unknown>>(object: T): ObjectEntries<T>;
+}
+
+/**
+ * Returns a new array containing the values of the array or object.
+ * @param source Either an array or an object
+ * @signature
+ *    P.values(source)
+ * @example
+ *    P.values(['x', 'y', 'z']) // => ['x', 'y', 'z']
+ *    P.values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']
+ *    P.pipe(
+ *      { a: 'x', b: 'y', c: 'z' },
+ *      P.values,
+ *      P.first
+ *    ) // => 'x'
+ * @pipeable
+ * @category Object
+ */
+declare function values<T>(source: Record<PropertyKey, T> | ArrayLike<T>): Array<T>;
+
+type Splitter = '-' | '_' | '/' | '.';
+type LastOfArray<T extends any[]> = T extends [...any, infer R] ? R : never;
+type RemoveLastOfArray<T extends any[]> = T extends [...infer F, any] ? F : never;
+type IsUpper<S extends string> = S extends Uppercase<S> ? true : false;
+type IsLower<S extends string> = S extends Lowercase<S> ? true : false;
+type SameLetterCase<X extends string, Y extends string> = IsUpper<X> extends IsUpper<Y> ? true : IsLower<X> extends IsLower<Y> ? true : false;
+type FirstOfString<S extends string> = S extends `${infer F}${string}` ? F : never;
+type RemoveFirstOfString<S extends string> = S extends `${string}${infer R}` ? R : never;
+type SplitByCase<T, Separator extends string = Splitter, Accumulator extends unknown[] = []> = string extends Separator ? string[] : T extends `${infer F}${infer R}` ? [LastOfArray<Accumulator>] extends [never] ? SplitByCase<R, Separator, [F]> : LastOfArray<Accumulator> extends string ? R extends '' ? SplitByCase<R, Separator, [
+    ...RemoveLastOfArray<Accumulator>,
+    `${LastOfArray<Accumulator>}${F}`
+]> : SameLetterCase<F, FirstOfString<R>> extends true ? F extends Separator ? FirstOfString<R> extends Separator ? SplitByCase<R, Separator, [...Accumulator, '']> : IsUpper<FirstOfString<R>> extends true ? SplitByCase<RemoveFirstOfString<R>, Separator, [
+    ...Accumulator,
+    FirstOfString<R>
+]> : SplitByCase<R, Separator, [...Accumulator, '']> : SplitByCase<R, Separator, [
+    ...RemoveLastOfArray<Accumulator>,
+    `${LastOfArray<Accumulator>}${F}`
+]> : IsLower<F> extends true ? SplitByCase<RemoveFirstOfString<R>, Separator, [
+    ...RemoveLastOfArray<Accumulator>,
+    `${LastOfArray<Accumulator>}${F}`,
+    FirstOfString<R>
+]> : SplitByCase<R, Separator, [...Accumulator, F]> : never : Accumulator extends [] ? T extends '' ? [] : string[] : Accumulator;
+type CapitalizedWords<T extends readonly string[], Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends string[]] ? CapitalizedWords<R, `${Accumulator}${Capitalize<F>}`> : Accumulator;
+type JoinLowercaseWords<T extends readonly string[], Joiner extends string, Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends string[]] ? Accumulator extends '' ? JoinLowercaseWords<R, Joiner, `${Accumulator}${Lowercase<F>}`> : JoinLowercaseWords<R, Joiner, `${Accumulator}${Joiner}${Lowercase<F>}`> : Accumulator;
+type PascalCase<T> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? CapitalizedWords<SplitByCase<T>> : never : T extends readonly string[] ? CapitalizedWords<T> : never;
+type CamelCase<T> = string extends T ? string : string[] extends T ? string : Uncapitalize<PascalCase<T>>;
+type JoinByCase<T, Joiner extends string> = string extends T ? string : string[] extends T ? string : T extends string ? SplitByCase<T> extends readonly string[] ? JoinLowercaseWords<SplitByCase<T>, Joiner> : never : T extends readonly string[] ? JoinLowercaseWords<T, Joiner> : never;
+
+declare function isUppercase(char?: string): boolean | undefined;
+declare function splitByCase<T extends string>(string_: T): SplitByCase<T>;
+declare function splitByCase<T extends string, Separator extends readonly string[]>(string_: T, separators: Separator): SplitByCase<T, Separator[number]>;
+declare function toUpperFirst<S extends string>(string_: S): Capitalize<S>;
+declare function toLowerFirst<S extends string>(string_: S): Uncapitalize<S>;
+declare function toPascalCase(): '';
+declare function toPascalCase<T extends string | readonly string[]>(string_?: T): PascalCase<T>;
+declare function toCamelCase(): '';
+declare function toCamelCase<T extends string | readonly string[]>(string_?: T): CamelCase<T>;
+declare function toKebabCase(): '';
+declare function toKebabCase<T extends string | readonly string[]>(string_?: T): JoinByCase<T, '-'>;
+declare function toKebabCase<T extends string | readonly string[], Joiner extends string>(string_: T, joiner: Joiner): JoinByCase<T, Joiner>;
+declare function toSnakeCase(): '';
+declare function toSnakeCase<T extends string | readonly string[]>(string_?: T): JoinByCase<T, '_'>;
+
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ * @param length the length of the random string
+ * @signature randomString(length)
+ * @example
+ *    randomString(5) // => aB92J
+ * @category String
+ */
+declare function randomString(length: number): string;
+
+/**
+ * Converts a path string to an array of keys.
+ * @param path a string path
+ * @signature P.stringToPathArray(path)
+ * @example P.stringToPathArray('a.b[0].c') // => ['a', 'b', 0, 'c']
+ * @dataFirst
+ * @category String
+ */
+declare function stringToPath<Path extends string>(path: Path): StringToPath<Path>;
+type StringToPath<T extends string> = T extends '' ? [] : T extends `[${infer Head}].${infer Tail}` ? [Head, ...StringToPath<Tail>] : T extends `.${infer Head}${infer Tail}` ? [Head, ...StringToPath<Tail>] : T extends `${infer Head}${infer Tail}` ? [Head, ...StringToPath<Tail>] : [T];
+
+/**
+ * Gives a single-word string description of the (native) type of a value, returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user Object types any further, reporting them all as 'Object'.
+ * @param val
+ * @signature
+ *    P.type(obj)
+ * @example
+ *    P.type({}); //=> "Object"
+ *    P.type(1); //=> "Number"
+ *    P.type(false); //=> "Boolean"
+ *    P.type('s'); //=> "String"
+ *    P.type(null); //=> "Null"
+ *    P.type([]); //=> "Array"
+ *    P.type(/[A-z]/); //=> "RegExp"
+ *    P.type(() => {}); //=> "Function"
+ *    P.type(undefined); //=> "Undefined"
+ * @category Type
+ */
+declare function type(val: any): string;
+
+declare const isBrowser: boolean;
+
+export { Joined, KEY_CODES, StringToPath, _setPath, addProp, allPass, anyPass, chunk, clamp, clone, compact, concat, convertToUnit, countBy, createPipe, difference, differenceWith, drop, dropLast, equals, filter, find, findIndex, findLast, findLastIndex, first, flatMap, flatMapToObj, flatten, flattenDeep, forEach, forEachObj, fromPairs, groupBy, humanReadableFileSize, identity, increaseWithUnit, indexBy, intersection, intersectionWith, invert, isArray, isBoolean, isBrowser, isDate, isDefined, isEmpty, isError, isFunction, isNil, isNonNull, isNot, isNumber, isObject, isPromise, isString, isTruthy, isUppercase, join, keys, last, length, map, mapKeys, mapToObj, mapValues, maxBy, meanBy, merge, mergeAll, minBy, noop, omit, omitBy, once, partition, pathOr, pick, pickBy, pipe, prop, purry, randomString, range, reduce, reject, reverse, sample, set, setPath, shuffle, sleep, sort, sortBy, splitAt, splitByCase, splitWhen, stringToPath, sumBy, swapIndices, swapProps, take, takeWhile, toCamelCase, toKebabCase, toLowerFirst, toPairs, toPascalCase, toSnakeCase, toUpperFirst, type, uniq, uniqBy, uniqWith, values, zip, zipObj, zipWith };