@vinicunca/perkakas 0.4.1 → 0.4.3

package/dist/index.d.cts

@@ -0,0 +1,4603 @@
+import { IsAny, ReadonlyTuple, Simplify, Merge, MergeDeep } from 'type-fest';
+
+/**
+ * Using event.code is not predictable since each machine may have different output
+ */
+declare const KEY_CODES: {
+    readonly ALT: "Alt";
+    readonly ARROW_DOWN: "ArrowDown";
+    readonly ARROW_LEFT: "ArrowLeft";
+    readonly ARROW_RIGHT: "ArrowRight";
+    readonly ARROW_UP: "ArrowUp";
+    readonly AT: "@";
+    readonly BACKSPACE: "Backspace";
+    readonly CTRL: "Control";
+    readonly DELETE: "Delete";
+    readonly END: "End";
+    readonly ENTER: "Enter";
+    readonly ESC: "Escape";
+    readonly HOME: "Home";
+    readonly KEY_F: "KEY_F";
+    readonly META: "Meta";
+    readonly PAGE_DOWN: "PageDown";
+    readonly PAGE_UP: "PageUp";
+    readonly SHIFT: "Shift";
+    readonly SPACE: "Space";
+    readonly TAB: "Tab";
+};
+
+/**
+ * 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: ReadonlyArray<T>) => K;
+type PredIndexedOptional<T, K> = (input: T, index?: number, array?: ReadonlyArray<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> | readonly [];
+type ObjectKeys$1<T extends object> = `${Exclude<keyof T, symbol>}`;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+
+type Chunked<T extends IterableContainer> = T[number] extends never ? [] : T extends readonly [...Array<unknown>, unknown] | readonly [unknown, ...Array<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>;
+
+/**
+ * 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<K | T>;
+/**
+ * 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<K | T>;
+
+type LazyEvaluator<T = unknown, R = T> = (item: T, index?: number, data?: ReadonlyArray<T>) => LazyResult<R>;
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: false;
+    next?: undefined;
+}
+interface LazyNext<T> {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: true;
+    next: T;
+}
+interface LazyMany<T> {
+    done: boolean;
+    hasMany: true;
+    hasNext: true;
+    next: Array<T>;
+}
+/**
+ * Perform left-to-right function composition.
+ * @param value The initial value.
+ * @param arguments 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;
+
+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.isDeepEqual,
+ *    ) // => [{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.isDeepEqual,
+ *    )([{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.isDeepEqual),
+ *      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: ReadonlyArray<TSecond>, isEquals: IsEquals$1<TFirst, TSecond>): LazyEvaluator<TFirst>;
+}
+
+/**
+ * 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 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 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): LazyEvaluator<T>;
+}
+
+declare const COMPARATORS: {
+    readonly asc: <T>(x: T, y: T) => boolean;
+    readonly desc: <T_1>(x: T_1, y: T_1) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = {
+    [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+    toString: () => string;
+} | {
+    valueOf: () => ComparablePrimitive;
+} | ComparablePrimitive;
+type ComparablePrimitive = boolean | number | string;
+
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before dropping the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.dropFirstBy(data, n, ...rules);
+ * @example
+ *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']
+ * @dataFirst
+ * @category Array
+ */
+declare function dropFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @params n - the number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.dropFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']
+ * @dataLast
+ * @category Array
+ */
+declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param data the array
+ * @param predicate the predicate
+ * @signature
+ *    P.dropLastWhile(data, predicate)
+ * @example
+ *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropLastWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param predicate the predicate
+ * @signature
+ *    P.dropLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]
+ * @dataLast
+ * @category Array
+ */
+declare function dropLastWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array,
+ * until the predicate returns false.
+ * The returned array includes the rest of the elements,
+ * starting with the element that produced false for the predicate.
+ *
+ * @param data the array
+ * @param predicate the predicate
+ * @signature
+ *    P.dropWhile(data, predicate)
+ * @example
+ *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropWhile<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): Array<T>;
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param predicate the predicate
+ * @signature
+ *    P.dropWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]
+ * @dataLast
+ * @category Array
+ */
+declare function dropWhile<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => Array<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]
+ *    // Excludes the values from `other` array
+ *    P.filter(array, P.isNot(P.isIncludedIn(other)))
+ *    // Returns a list of elements that exist in both array.
+ *    P.filter(array, P.isIncludedIn(other))
+ * @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]
+ *    // Filter out all falsy values
+ *    P.filter(P.isTruthy)
+ *    // Counts how many values of the collection pass the specified predicate
+ *    P.filter(fn).length
+ *    // Excludes the values from `other` array
+ *    P.filter(P.isNot(P.isIncludedIn(other)))
+ *    // Returns a list of elements that exist in both array.
+ *    P.filter(P.isIncludedIn(other))
+ * @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: ReadonlyArray<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: ReadonlyArray<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>) => LazyEvaluator<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T>) & {
+        readonly 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>(items: 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 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>): (items: 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>) => LazyEvaluator<T, number>) & {
+        readonly single: true;
+    };
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T, number>) & {
+        readonly indexed: true;
+    } & {
+        readonly 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 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>(items: 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>) => LazyEvaluator<T>) & {
+        readonly single: true;
+    };
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T>) & {
+        readonly indexed: true;
+    } & {
+        readonly 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] ? Last | Pre[0] : 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>(): LazyEvaluator<T>;
+    namespace lazy {
+        const single = true;
+    }
+}
+
+type FirstBy<T extends IterableContainer> = (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined) | T[number];
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(...rules)(data);
+ * @example
+ *   const max = P.pipe([1,2,3], P.firstBy([P.identity, "desc"])); // => 3;
+ *   const min = P.pipe([1,2,3], P.firstBy([1,2,3])); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
+ *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
+ * @dataLast
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data an array of items
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(data, ...rules);
+ * @example
+ *   const max = P.firstBy([1,2,3], [P.identity, "desc"]); // => 3;
+ *   const min = P.firstBy([1,2,3], P.identity); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
+ *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
+ * @dataFirst
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
+
+/**
+ * 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 PropertyKey, 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 PropertyKey, V>(fn: (element: T) => Array<[K, V]>): (array: ReadonlyArray<T>) => Record<K, V>;
+declare namespace flatMapToObj {
+    function indexed<T, K extends PropertyKey, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => Array<[K, V]>): Record<K, V>;
+    function indexed<T, K extends PropertyKey, 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 | ReadonlyArray<K>): Array<K>;
+/**
+ * Map each element of an array using a defined callback function and flatten the mapped result.
+ *
+ * @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 | ReadonlyArray<K>): (array: ReadonlyArray<T>) => Array<K>;
+declare namespace flatMap {
+    function lazy<T, K>(fn: (input: T) => K | ReadonlyArray<K>): LazyEvaluator<T, K>;
+}
+
+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`.
+ *
+ * @param items the target array
+ * @signature
+ *   P.flattenDeep(array)
+ * @example
+ *    P.flattenDeep([[1, 2], [[3], [4, 5]]]) // => [1, 2, 3, 4, 5]
+ * @pipeable
+ * @category Array
+ */
+declare function flattenDeep<T>(items: ReadonlyArray<T>): Array<FlattenDeep<T>>;
+/**
+ * Recursively flattens `array`.
+ *
+ * @signature
+ *   P.flattenDeep()(array)
+ * @example
+ *    P.pipe(
+ *      [[1, 2], [[3], [4, 5]]],
+ *      P.flattenDeep(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function flattenDeep<T>(): (items: ReadonlyArray<T>) => Array<FlattenDeep<T>>;
+declare namespace flattenDeep {
+    function lazy<T>(): LazyEvaluator<T, any>;
+}
+
+type Flatten<T> = T extends ReadonlyArray<infer K> ? K : T;
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @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]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+declare function flatten<T>(items: ReadonlyArray<T>): Array<Flatten<T>>;
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @signature
+ *   P.flatten()(array)
+ * @example
+ *    P.pipe(
+ *      [[1, 2], [3], [4, 5]],
+ *      P.flatten(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+declare function flatten<T>(): (items: ReadonlyArray<T>) => Array<Flatten<T>>;
+declare namespace flatten {
+    function lazy<T>(): LazyEvaluator<T, Flatten<T>>;
+}
+
+/**
+ * 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>) => LazyEvaluator<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, void>) => LazyEvaluator<T>) & {
+        readonly indexed: true;
+    };
+}
+
+interface Strict$7 {
+    <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>(fn: PredIndexed<Value, Key | undefined>): (items: ReadonlyArray<Value>) => StrictOut$2<Value, Key>;
+        <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: PredIndexed<Value, Key | undefined>): 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$7;
+}
+
+type ArrayMinN<T, N extends number> = number extends N ? Array<T> : N extends 0 ? Array<T> : [...ReadonlyTuple<T, N>, ...Array<T>];
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type accordingly so that those indices are defined when
+ * accessing the array even when using typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data the input array
+ * @param minimum the minimum number of elements the array must have
+ * @return true if the array's length is *at least* `minimum`.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T, N extends number>(data: ReadonlyArray<T>, minimum: N): data is ArrayMinN<T, N>;
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type accordingly so that those indices are defined when
+ * accessing the array even when using typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum the minimum number of elements the array must have
+ * @return true if the array's length is *at least* `minimum`.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: N): <T>(data: ReadonlyArray<T>) => data is ArrayMinN<T, N>;
+
+declare function indexByStrict<K extends PropertyKey, T>(array: ReadonlyArray<T>, fn: (item: T) => K): Partial<Record<K, T>>;
+declare function indexByStrict<K extends PropertyKey, T>(fn: (item: T) => K): (array: ReadonlyArray<T>) => Partial<Record<K, T>>;
+/**
+ * Converts a list of objects into an object indexing the objects by the given key (casted to a string).
+ * Use the strict version to maintain the given key's type, so long as it is a valid `PropertyKey`.
+ *
+ * @param array the array
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(array, fn)
+ *    P.indexBy.strict(array, fn)
+ * @example
+ *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {"3": 'two', "5": 'three'}
+ *    P.indexBy.strict(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ * @strict
+ */
+declare function indexBy<T>(array: ReadonlyArray<T>, fn: (item: T) => unknown): Record<string, T>;
+/**
+ * Converts a list of objects into an object indexing the objects by the given key.
+ * (casted to a string). Use the strict version to maintain the given key's type, so
+ * long as it is a valid `PropertyKey`.
+ *
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(fn)(array)
+ *    P.indexBy.strict(fn)(array)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'three'],
+ *      P.indexBy(x => x.length)
+ *    ) // => {"3": 'two', "5": 'three'}
+ *    P.pipe(
+ *      ['one', 'two', 'three'],
+ *      P.indexBy.strict(x => x.length)
+ *    ) // => {3: 'two', 5: 'three'}
+ * @dataLast
+ * @indexed
+ * @category Array
+ * @strict
+ */
+declare function indexBy<T>(fn: (item: T) => unknown): (array: ReadonlyArray<T>) => Record<string, T>;
+declare namespace indexBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, unknown>): Record<string, T>;
+    function indexed<T>(fn: PredIndexed<T, unknown>): (array: ReadonlyArray<T>) => Record<string, T>;
+    const strict: typeof indexByStrict;
+}
+
+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: ReadonlyArray<TSecond>, comparator: Comparator<TFirst, TSecond>): LazyEvaluator<TFirst>;
+}
+
+type Joinable = bigint | boolean | null | number | string | 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 null | undefined ? Fallback | NonNullable<T> : 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 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`.
+ *
+ * @param array the array
+ * @signature
+ *    P.last(array)
+ * @example
+ *    P.last([1, 2, 3]) // => 3
+ *    P.last([]) // => undefined
+ * @category Array
+ * @pipeable
+ * @dataFirst
+ */
+declare function last<T>(array: Readonly<NonEmptyArray<T>>): T;
+declare function last<T>(array: ReadonlyArray<T>): T | undefined;
+/**
+ * Gets the last element of `array`.
+ *
+ * @signature
+ *    P.last()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.last(),
+ *      x => x + 1
+ *    ); // => 17
+ * @category Array
+ * @pipeable
+ * @dataLast
+ */
+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$6 {
+    <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>) => LazyEvaluator<T, K>;
+    const lazyIndexed: (<T, K>(fn: PredIndexedOptional<T, K>) => LazyEvaluator<T, K>) & {
+        readonly indexed: true;
+    };
+    const strict: Strict$6;
+}
+
+/**
+ * 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 PropertyKey, 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 PropertyKey, V>(fn: (element: T) => [K, V]): (array: ReadonlyArray<T>) => Record<K, V>;
+declare namespace mapToObj {
+    function indexed<T, K extends PropertyKey, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => [K, V]): Record<K, V>;
+    function indexed<T, K extends PropertyKey, 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: readonly [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;
+}
+
+/**
+ * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
+ * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
+ * Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.
+ *
+ * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
+ * but only for `index === 0`.
+ * See `takeFirstBy` to get all the elements up to and including `index`.
+ *
+ * @param data - The input array.
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(data, index, ...rules);
+ * @example
+ *   P.nthBy([2,1,4,5,3,], 2, identity); // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
+/**
+ * Retrieves the element that would be at the given index if the array were sorted according to specified rules.
+ * This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*.
+ * Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.
+ *
+ * See also `firstBy` which provides an even more efficient algorithm and a stricter return type,
+ * but only for `index === 0`.
+ * See `takeFirstBy` to get all the elements up to and including `index`.
+ *
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(index, ...rules)(data);
+ * @example
+ *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity)); // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
+
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
+ * inferred type is lost.
+ *
+ * @param array the target array
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @pipeable
+ * @category Array
+ * @dataFirst
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ * Note: In `pipe`, use `only()` form instead of `only`. Otherwise, the
+ * inferred type is lost.
+ *
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @pipeable
+ * @category Array
+ * @dataLast
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<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 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>;
+
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param data - The input array.
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(data, item, ...rules)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.rankBy(DATA, 0, P.prop('a')) // => 0
+ *   P.rankBy(DATA, 1, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 2, P.prop('a')) // => 1
+ *   P.rankBy(DATA, 3, P.prop('a')) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function rankBy<T>(data: ReadonlyArray<T>, item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): number;
+/**
+ * Calculates the rank of an item in an array based on `rules`. The rank is the position where the item would appear in the sorted array. This function provides an efficient way to determine the rank in *O(n)* time, compared to *O(nlogn)* for the equivalent `sortedIndex(sortBy(data, ...rules), item)`.
+ *
+ * @param item - The item whose rank is to be determined.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns - The rank of the item in the sorted array in the range [0..data.length]
+ * @signature
+ *   P.rankBy(item, ...rules)(data)
+ * @example
+ *   const DATA = [{ a: 5 }, { a: 1 }, { a: 3 }] as const;
+ *   P.pipe(DATA, P.rankBy(0, P.prop('a'))) // => 0
+ *   P.pipe(DATA, P.rankBy(1, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(2, P.prop('a'))) // => 1
+ *   P.pipe(DATA, P.rankBy(3, P.prop('a'))) // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function rankBy<T>(item: T, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => 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 items 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: ReadonlyArray<T>) => K, initialValue: K): K;
+    function indexed<T, K>(fn: (acc: K, item: T, index: number, items: ReadonlyArray<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 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>) => LazyEvaluator<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, boolean>) => LazyEvaluator<T>) & {
+        readonly 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 an 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 an 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 data 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 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$5 {
+    <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$5;
+}
+
+interface Strict$4 {
+    <T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => SortedBy<T>;
+    <T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): SortedBy<T>;
+}
+type SortedBy<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the native `Array.prototype.sort` but is performed on a shallow copy of the array to avoid mutating the original data.
+ *
+ * To maintain the shape of more complex inputs (like non-empty arrays, tuples, etc...) use the `strict` variant.
+ *
+ * There are several other functions that take order rules and **bypass** the need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @return - A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(...rules)(data)
+ *    P.sortBy.strict(...rules)(data)
+ * @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>(...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+/**
+ * Sorts `data` using the provided ordering rules. The `sort` is done via the native `Array.prototype.sort` but is performed on a shallow copy of the array to avoid mutating the original data.
+ *
+ * To maintain the shape of more complex inputs (like non-empty arrays, tuples, etc...) use the `strict` variant.
+ *
+ * There are several other functions that take order rules and **bypass** the need to sort the array first (in *O(nlogn)* time):
+ * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
+ * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
+ * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
+ * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
+ * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
+ * Refer to the docs for more details.
+ *
+ * @param array - The input array.
+ * @param sortRules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @return - A shallow copy of the input array sorted by the provided rules.
+ * @signature
+ *    P.sortBy(data, ...rules)
+ *    P.sortBy.strict(data, ...rules)
+ * @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<OrderRule<T>>>): Array<T>;
+declare namespace sortBy {
+    const strict: Strict$4;
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @return - Insertion index (In the range 0..array.length)
+ *
+ * @signature
+ *    P.sortedIndex(data, item)
+ * @example
+ *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3
+ * @dataFirst
+ * @category Array
+ *
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @return - Insertion index (In the range 0..array.length)
+ *
+ * @signature
+ *    P.sortedIndex(item)(data)
+ * @example
+ *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3
+ * @dataLast
+ * @category Array
+ *
+ * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
+
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `true` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ *
+ * @param data - Array, "sorted" by `predicate`
+ * @param predicate - A predicate which also defines the array's order
+ * @return - Index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedIndexWith(data, predicate)
+ * @example
+ *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
+ * @dataFirst
+ * @indexed
+ * @category Array
+ *
+ * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (item: T) => boolean): number;
+/**
+ * Performs a **binary search** for the index of the item at which the predicate
+ * stops returning `true`. This function assumes that the array is "sorted" in
+ * regards to the predicate, meaning that running the predicate as a mapper on
+ * it would result in an array `[...true[], ...false[]]`.
+ * This stricter requirement from the predicate provides us 2 benefits over
+ * `findIndex` which does a similar thing:
+ * 1. It would run at O(logN) time instead of O(N) time.
+ * 2. It always returns a value (it would return `data.length` if the
+ * predicate returns `false` for all items).
+ *
+ * This function is the basis for all other sortedIndex functions which search
+ * for a specific item in a sorted array, and it could be used to perform
+ * similar efficient searches.
+ *
+ * @param predicate - A predicate which also defines the array's order
+ * @return - Index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedIndexWith(predicate)(data)
+ * @example
+ *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
+ * @dataLast
+ * @indexed
+ * @category Array
+ *
+ * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexWith<T>(predicate: (item: T) => boolean): (data: ReadonlyArray<T>) => number;
+declare namespace sortedIndexWith {
+    function indexed<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number) => NonNullable<unknown>): number;
+    function indexed<T>(predicate: (item: T, index: number) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that `splice(sortedIndex, 0, item)`
+ * would result in maintaining the arrays sort-ness. The array can contain
+ * duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array.
+ * @return - Insertion index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataFirst
+ * @indexed
+ * @category Array
+ *
+ * @see sortedIndex, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T) => NonNullable<unknown>): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order using a value function; so that `splice(sortedIndex, 0, item)`
+ * would result in maintaining the arrays sort-ness. The array can contain
+ * duplicates.
+ * If the item already exists in the array the index would be of the *first*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @param valueFunction - All comparisons would be performed on the result of
+ * calling this function on each compared item. Preferably this function should
+ * return a `number` or `string`. This function should be the same as the one
+ * provided to sortBy to sort the array.
+ * @return - Insertion index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedIndexBy(data, item, valueFunction)
+ * @example
+ *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
+ * @dataLast
+ * @indexed
+ * @category Array
+ *
+ * @see sortedIndex, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
+ */
+declare function sortedIndexBy<T>(item: T, valueFunction: (item: T) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
+declare namespace sortedIndexBy {
+    function indexed<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): number;
+    function indexed<T>(item: T, valueFunction: (item: T, index?: number) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
+}
+
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *last*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param data - The (ascending) sorted array.
+ * @param item - The item to insert.
+ * @return - Insertion index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedLastIndex(data, item)
+ * @example
+ *    P.sortedLastIndex(['a','a','b','c','c'], 'c') // => 5
+ * @dataFirst
+ * @category Array
+ *
+ * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy
+ */
+declare function sortedLastIndex<T>(data: ReadonlyArray<T>, item: T): number;
+/**
+ * Find the insertion position (index) of an item in an array with items sorted
+ * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
+ * maintaining the array's sort-ness. The array can contain duplicates.
+ * If the item already exists in the array the index would be of the *last*
+ * occurrence of the item.
+ *
+ * Runs in O(logN) time.
+ *
+ * @param item - The item to insert.
+ * @return - Insertion index (In the range 0..data.length)
+ *
+ * @signature
+ *    P.sortedLastIndex(item)(data)
+ * @example
+ *    P.pipe(['a','a','b','c','c'], sortedLastIndex('c')) // => 5
+ * @dataLast
+ * @category Array
+ *
+ * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndexBy
+ */
+declare function sortedLastIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
+
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ *
+ * @param items the array to splice.
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(items, start, deleteCount, replacement)
+ * @example
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]
+ *    P.splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]
+ * @dataFirst
+ * @category Array
+ */
+declare function splice<T>(items: ReadonlyArray<T>, start: number, deleteCount: number, replacement: ReadonlyArray<T>): Array<T>;
+/**
+ * Removes elements from an array and, inserts new elements in their place.
+ *
+ * @param start the index from which to start removing elements.
+ * @param deleteCount the number of elements to remove.
+ * @param replacement the elements to insert into the array in place of the deleted elements.
+ * @signature
+ *    P.splice(start, deleteCount, replacement)(items)
+ * @example
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [])) // => [1,2,6,7,8]
+ *    P.pipe([1,2,3,4,5,6,7,8], P.splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]
+ * @dataLast
+ * @category Array
+ */
+declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<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(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 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): LazyEvaluator<T>;
+}
+
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params data - the input array
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria.
+ * This allows you to avoid sorting the array before taking the items.
+ * The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @params n - the number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria.
+ * Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns a subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<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.
+ * @param array
+ * @signature
+ *    P.uniq(array)
+ * @example
+ *    P.uniq([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ * @pipeable
+ * @category Array
+ * @dataFirst
+ */
+declare function uniq<T>(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.
+ * @param array
+ * @signature
+ *    P.uniq()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.uniq(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @pipeable
+ * @category Array
+ * @dataLast
+ */
+declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
+declare namespace uniq {
+    function lazy<T>(): LazyEvaluator<T>;
+}
+
+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>): LazyEvaluator<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.isDeepEqual,
+ *    ) // => [{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.isDeepEqual)(
+ *      [{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.isDeepEqual),
+ *      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_ & {
+        readonly indexed: true;
+    };
+}
+
+interface Strict$3 {
+    <F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zip<F, S>;
+    <S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zip<F, S>;
+}
+type Zip<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
+    [LeftHead, RightHead],
+    ...Zip<LeftRest, RightRest>
+] : [
+    [LeftHead, Right[number]],
+    ...Zip<LeftRest, Right>
+] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zip<Left, RightRest>] : Array<[Left[number], Right[number]]>;
+/**
+ * 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.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
+ * @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']] (type: [number, string][])
+ *   P.zip.strict([1, 2] as const, ['a', 'b'] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
+ * @dataFirst
+ * @category Array
+ * @strict
+ */
+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.
+ *
+ * If the input array are tuples, you can use the strict option
+ * to get another tuple instead of a generic array type.
+ * @param second the second input list
+ * @signature
+ *   P.zip(second)(first)
+ * @example
+ *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
+ *   P.zip.strict(['a', 'b'] as const)([1, 2] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
+ * @dataLast
+ * @category Array
+ * @strict
+ */
+declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
+declare namespace zip {
+    const strict: Strict$3;
+}
+
+/**
+ * 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 PropertyKey, 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 PropertyKey>(first: ReadonlyArray<F>) => Record<F, S>;
+
+type ZippingFunction<F = unknown, S = unknown, R = unknown> = (f: F, s: S) => R;
+/**
+ * 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: ReadonlyArray<F>, second: ReadonlyArray<S>, fn: ZippingFunction<F, 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: ZippingFunction<F, S, R>): (first: ReadonlyArray<F>, second: ReadonlyArray<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: ZippingFunction<F, S, R>, second: ReadonlyArray<S>): (first: ReadonlyArray<F>) => Array<R>;
+
+type Case<In, Out, Thru extends In = In> = readonly [
+    when: ((data: In) => boolean) | ((data: In) => data is Thru),
+    then: (data: Thru) => Out
+];
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.conditional.defaultCase(
+ *         (something) => `Hello something (${JSON.stringify(something)})`,
+ *       ),
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+declare namespace conditional {
+    /**
+     * A simplified case that accepts all data. Put this as the last case to
+     * prevent an exception from being thrown when none of the previous cases
+     * match.
+     * If this is not the last case it will short-circuit anything after it.
+     * @param then - You only need to provide the transformer, the predicate is
+     * implicit. @default () => undefined, which is how Lodash and Ramda handle
+     * the final fallback case.
+     */
+    function defaultCase<In>(then?: (data: In) => unknown): readonly [() => boolean, (data: In) => unknown];
+}
+
+/**
+ * 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;
+
+interface Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> {
+    /**
+     * The last computed value of the debounced function.
+     */
+    readonly cachedValue: ReturnType<F> | undefined;
+    /**
+     * Invoke the debounced function.
+     * @param args - same as the args for the debounced function.
+     * @returns - the last computed value of the debounced function with the
+     * latest args provided to it. If `timing` does not include `leading` then the
+     * the function would return `undefined` until the first cool-down period is
+     * over, otherwise the function would always return the return type of the
+     * debounced function.
+     */
+    readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+    /**
+     * Cancels any debounced functions without calling them, effectively resetting
+     * the debouncer to the same state it is when initially created.
+     */
+    readonly cancel: () => void;
+    /**
+     * Similar to `cancel`, but would also trigger the `trailing` invocation if
+     * the debouncer would run one at the end of the cool-down period.
+     */
+    readonly flush: () => ReturnType<F> | undefined;
+    /**
+     * Is `true` when there is an active cool-down period currently debouncing
+     * invocations.
+     */
+    readonly isPending: boolean;
+}
+interface DebounceOptions {
+    readonly maxWaitMs?: number;
+    readonly waitMs?: number;
+}
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ * @param func The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns a debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity, { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends (...args: any) => any>(func: F, options: {
+    readonly timing?: 'trailing';
+} & DebounceOptions): Debouncer<F>;
+declare function debounce<F extends (...args: any) => any>(func: F, options: ({
+    readonly timing: 'both';
+} & DebounceOptions) | ({
+    readonly timing: 'leading';
+} & Omit<DebounceOptions, 'maxWaitMs'>)): Debouncer<F, false>;
+
+type LazyEvaluatorFactory = (...args: any) => LazyEvaluator;
+interface MaybeLazyFunction {
+    (...args: any): unknown;
+    readonly lazy?: LazyEvaluatorFactory;
+}
+/**
+ * Creates a function with `dataFirst` and `dataLast` 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.
+ *
+ * !IMPORTANT: functions that simply call `purry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn the function to purry.
+ * @param args the arguments
+ * @param lazyFactory - A lazy version of the function to purry.
+ * @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: MaybeLazyFunction, args: IArguments | ReadonlyArray<unknown>, lazyFactory?: LazyEvaluatorFactory): unknown;
+
+/**
+ * Delay execution for a given number of milliseconds.
+ *
+ * @param timeout the number of milliseconds to wait
+ * @signature
+ *   P.sleep(timeout)
+ * @example
+ *  P.sleep(1000) // => Promise<void>
+ * @category Function
+ */
+declare function sleep(timeout: number): Promise<void>;
+
+/**
+ * Calls an input function `n` times, returning an array containing the results
+ * of those function calls.
+ *
+ * `fn` is passed one argument: The current value of `n`, which begins at `0`
+ * and is gradually incremented to `n - 1`.
+ *
+ * @param count A value between `0` and `n - 1`. Increments after each function call.
+ * @param fn The function to invoke. Passed one argument, the current value of `n`.
+ * @return An array containing the return values of all calls to `fn`.
+ * @example times(5, identity); //=> [0, 1, 2, 3, 4]
+ * @dataFirst
+ */
+declare function times<T>(count: number, fn: (n: number) => T): Array<T>;
+/**
+ * Calls an input function `n` times, returning an array containing the results
+ * of those function calls.
+ *
+ * `fn` is passed one argument: The current value of `n`, which begins at `0`
+ * and is gradually incremented to `n - 1`.
+ *
+ * @param fn The function to invoke. Passed one argument, the current value of `n`.
+ * @return An array containing the return values of all calls to `fn`.
+ * @example P.times(identity)(5); //=> [0, 1, 2, 3, 4]
+ * @dataLast
+ */
+declare function times<T>(fn: (n: number) => T): (count: number) => Array<T>;
+
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param data - The object to test.
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(data, subObject)
+ * @example
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
+ *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(data: T, subObject: S): data is Simplify<S & T>;
+/**
+ * Checks if `subObject` is a sub-object of `object`, which means for every
+ * property and value in `subObject`, there's the same property in `object`
+ * with an equal value. Equality is checked with `isDeepEqual`.
+ *
+ * @param subObject - The sub-object to test against.
+ * @signature
+ *    P.hasSubObject(subObject)(data)
+ * @example
+ *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
+ *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
+ *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function hasSubObject<T, S extends Partial<T>>(subObject: S): (data: T) => data is Simplify<S & T>;
+
+/**
+ * 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: ArrayLike<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
+
+/**
+ * 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 NarrowedTo<T, boolean>;
+
+/**
+ * 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;
+
+/**
+ * Performs a deep *semantic* comparison between two values to determine if they
+ * are equivalent. For primitive values this is equivalent to `===`, for arrays
+ * the check would be performed on every item recursively, in order, and for
+ * objects all props will be compared recursively. The built-in Date and RegExp
+ * are special-cased and will be compared by their values.
+ *
+ * !IMPORTANT: Maps, Sets and TypedArrays, and symbol properties of objects  are
+ * not supported right now and might result in unexpected behavior.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isDeepEqual(data, other)
+ * @example
+ *    P.isDeepEqual(1, 1) //=> true
+ *    P.isDeepEqual(1, '1') //=> false
+ *    P.isDeepEqual([1, 2, 3], [1, 2, 3]) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function isDeepEqual<T, S extends T = T>(data: T, other: S): data is S;
+/**
+ * Performs a deep *semantic* comparison between two values to determine if they
+ * are equivalent. For primitive values this is equivalent to `===`, for arrays
+ * the check would be performed on every item recursively, in order, and for
+ * objects all props will be compared recursively. The built-in Date and RegExp
+ * are special-cased and will be compared by their values.
+ *
+ * !IMPORTANT: Maps, Sets and TypedArrays, and symbol properties of objects  are
+ * not supported right now and might result in unexpected behavior.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isDeepEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isDeepEqual(1)); //=> true
+ *    P.pipe(1, P.isDeepEqual('1')); //=> false
+ *    P.pipe([1, 2, 3], P.isDeepEqual([1, 2, 3])); //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function isDeepEqual<T, S extends T = T>(other: S): (data: T) => data is S;
+
+/**
+ * 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.
+ *
+ * `undefined` is also considered empty, but only when it's in a union with a
+ * `string` or string-like type.
+ *
+ * This guard doesn't work negated because of typescript limitations! If you
+ * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`
+ * and not `!P.isEmpty(data)`. For strings and objects there's no way in
+ * typescript to narrow the result to a non-empty type.
+ *
+ * @param data the variable to check
+ * @signature
+ *    P.isEmpty(data)
+ * @returns true if the passed input is empty, false otherwise
+ * @example
+ *    P.isEmpty(undefined) //=>true
+ *    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 Guard
+ */
+declare function isEmpty<T extends string | undefined>(data: T): data is ('' extends T ? '' : never) | (undefined extends T ? undefined : never);
+declare function isEmpty(data: IterableContainer): 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: Error | T): 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: Function | T): data is DefinitelyFunction<T>;
+
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). The input's type is narrowed to the container's type if
+ * possible.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param data - The item that is checked.
+ * @param container - The items that are checked against.
+ * @returns A narrowed version of the input data on success, `false` otherwise.
+ * @signature
+ *   P.isIncludedIn(data, container);
+ * @example
+ *   P.isIncludedIn(2, [1, 2, 3]); // => true
+ *   P.isIncludedIn(4, [1, 2, 3]); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.isIncludedIn(data, ["cat", "dog"] as const); // true (typed "cat" | "dog");
+ * @dataFirst
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends T>(data: T, container: IterableContainer<S>): data is S;
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). The input's type is narrowed to the container's type if
+ * possible.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param container - The items that are checked against.
+ * @returns A narrowed version of the input data on success, `false` otherwise.
+ * @signature
+ *   P.isIncludedIn(container)(data);
+ * @example
+ *   P.pipe(2, P.isIncludedIn([1, 2, 3])); // => true
+ *   P.pipe(4, P.isIncludedIn([1, 2, 3])); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.pipe(
+ *     data,
+ *     P.isIncludedIn(["cat", "dog"] as const),
+ *   ); // => true (typed "cat" | "dog");
+ * @dataLast
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends T>(container: IterableContainer<S>): (data: T) => data is S;
+
+/**
+ * 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) => boolean): (data: T) => boolean;
+
+/**
+ * A function that checks if the passed parameter is a number and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isNumber(data)
+ * @returns true if the passed input is a number, false otherwise
+ * @example
+ *    P.isNumber(1) //=> true
+ *    P.isNumber('notANumber') //=> false
+ * @category Guard
+ */
+declare function isNumber<T>(data: T | number): data is NarrowedTo<T, number>;
+
+/**
+ * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
+ *
+ * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
+ *
+ * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
+ *
+ * @param data - The variable to check.
+ * @returns - The input type, narrowed to only plain objects.
+ * @signature
+ *    P.isObject(data)
+ * @example
+ *    // true
+ *    P.isObject({}) //=> true
+ *    P.isObject({ a: 123 }) //=> true
+ *
+ *    // false
+ *    P.isObject([]) //=> false
+ *    P.isObject(Promise.resolve("something")) //=> false
+ *    P.isObject(new Date()) //=> false
+ *    P.isObject(new Error("error")) //=> false
+ *    P.isObject('somethingElse') //=> false
+ *    P.isObject(null) //=> false
+ * @category Guard
+ */
+declare function isObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
+
+/**
+ * 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>;
+
+/**
+ * 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 NarrowedTo<T, string>;
+
+/**
+ * A function that checks if the passed parameter is a symbol and narrows its type accordingly
+ * @param data the variable to check
+ * @signature
+ *    P.isSymbol(data)
+ * @returns true if the passed input is a symbol, false otherwise
+ * @example
+ *    P.isSymbol(Symbol('foo')) //=> true
+ *    P.isSymbol(1) //=> false
+ * @category Guard
+ */
+declare function isSymbol<T>(data: T | symbol): data is NarrowedTo<T, symbol>;
+
+/**
+ * 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, '' | 0 | false | null | undefined>;
+
+/**
+ * Adds two numbers.
+ * @param value The number.
+ * @param addend The number to add to the value.
+ * @signature
+ *    P.add(value, addend);
+ * @example
+ *    P.add(10, 5) // => 15
+ *    P.add(10, -5) // => 5
+ *    P.reduce([1, 2, 3, 4], P.add, 0) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function add(value: number, addend: number): number;
+/**
+ * Adds two numbers.
+ * @param addend The number to add to the value.
+ * @signature
+ *    P.add(addend)(value);
+ * @example
+ *    P.add(5)(10) // => 15
+ *    P.add(-5)(10) // => 5
+ *    P.map([1, 2, 3, 4], P.add(1)) // => [2, 3, 4, 5]
+ * @dataLast
+ * @category Number
+ */
+declare function add(addend: number): (value: number) => number;
+
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ *
+ * @param value The number to round up.
+ * @param precision The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(value, precision);
+ * @example
+ *    P.ceil(123.9876, 3) // => 123.988
+ *    P.ceil(483.22243, 1) // => 483.3
+ *    P.ceil(8541, -1) // => 8550
+ *    P.ceil(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function ceil(value: number, precision: number): number;
+/**
+ * Rounds up a given number to a specific precision.
+ * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.ceil` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision The precision to round up to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.ceil(precision)(value);
+ * @example
+ *    P.ceil(3)(123.9876) // => 123.988
+ *    P.ceil(1)(483.22243) // => 483.3
+ *    P.ceil(-1)(8541) // => 8550
+ *    P.ceil(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function ceil(precision: number): (value: number) => number;
+
+interface Limits {
+    readonly max?: number;
+    readonly min?: number;
+}
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ * @param value the number
+ * @param limits the bounds limits
+ * @param limits.min the minimal bounds limits
+ * @param limits.max the maximal bounds limits
+ * @signature
+ *    P.clamp(value, { min, max });
+ * @example
+ *    P.clamp(10, { min: 20 }) // => 20
+ *    P.clamp(10, { max: 5 }) // => 5
+ *    P.clamp(10, { max: 20, min: 5 }) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function clamp(value: number, limits: Limits): number;
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ * @param limits the bounds limits
+ * @param limits.min the minimal bounds limits
+ * @param limits.max the maximal bounds limits
+ * @signature
+ *    P.clamp({ min, max })(value);
+ * @example
+ *    P.clamp({ min: 20 })(10) // => 20
+ *    P.clamp({ max: 5 })(10) // => 5
+ *    P.clamp({ max: 20, min: 5 })(10) // => 10
+ * @dataLast
+ * @category Number
+ */
+declare function clamp(limits: Limits): (value: number) => number;
+
+/**
+ * Divides two numbers.
+ * @param value The number.
+ * @param divisor The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ * @param divisor The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: number): (value: number) => number;
+
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param value The number to round down.
+ * @param precision The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(value, precision);
+ * @example
+ *    P.floor(123.9876, 3) // => 123.987
+ *    P.floor(483.22243, 1) // => 483.2
+ *    P.floor(8541, -1) // => 8540
+ *    P.floor(456789, -3) // => 456000
+ * @dataFirst
+ * @category Number
+ */
+declare function floor(value: number, precision: number): number;
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(precision)(value);
+ * @example
+ *    P.floor(3)(123.9876) // => 123.987
+ *    P.floor(1)(483.22243) // => 483.2
+ *    P.floor(-1)(8541) // => 8540
+ *    P.floor(-3)(456789) // => 456000
+ * @dataLast
+ * @category Number
+ */
+declare function floor(precision: number): (value: number) => number;
+
+/**
+ * Multiplies two numbers.
+ *
+ * @param value The number.
+ * @param multiplicand The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * @param multiplicand The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: number): (value: number) => number;
+
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param value The number to round.
+ * @param precision The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(value, precision);
+ * @example
+ *    P.round(123.9876, 3) // => 123.988
+ *    P.round(483.22243, 1) // => 483.2
+ *    P.round(8541, -1) // => 8540
+ *    P.round(456789, -3) // => 457000
+ * @dataFirst
+ * @category Number
+ */
+declare function round(value: number, precision: number): number;
+/**
+ * Rounds a given number to a specific precision.
+ * If you'd like to round to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.round` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision The precision to round to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.round(precision)(value);
+ * @example
+ *    P.round(3)(123.9876) // => 123.988
+ *    P.round(1)(483.22243) // => 483.2
+ *    P.round(-1)(8541) // => 8540
+ *    P.round(-3)(456789) // => 457000
+ * @dataLast
+ * @category Number
+ */
+declare function round(precision: number): (value: number) => number;
+
+/**
+ * Subtracts two numbers.
+ *
+ * @param value The number.
+ * @param subtrahend The number to subtract from the value.
+ * @signature
+ *    P.subtract(value, subtrahend);
+ * @example
+ *    P.subtract(10, 5) // => 5
+ *    P.subtract(10, -5) // => 15
+ *    R.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function subtract(value: number, subtrahend: number): number;
+/**
+ * Subtracts two numbers.
+ *
+ * @param subtrahend The number to subtract from the value.
+ * @signature
+ *    P.subtract(subtrahend)(value);
+ * @example
+ *    P.subtract(5)(10) // => 5
+ *    P.subtract(-5)(10) // => 15
+ *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
+ * @dataLast
+ * @category Number
+ */
+declare function subtract(subtrahend: 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, unknown>, 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, unknown>, 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;
+
+type IndexedIteratee<T extends Record<PropertyKey, unknown>, K extends keyof T> = (value: T[K], key: K, obj: T) => void;
+type UnindexedIteratee<T extends Record<PropertyKey, unknown>> = (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, unknown>>(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, unknown>>(fn: UnindexedIteratee<T>): (object: T) => T;
+declare namespace forEachObj {
+    function indexed<T extends Record<PropertyKey, unknown>>(object: T, fn: IndexedIteratee<T, keyof T>): T;
+    function indexed<T extends Record<PropertyKey, unknown>>(fn: IndexedIteratee<T, keyof T>): (object: T) => T;
+}
+
+type ExactlyOneKey<T, V> = T extends PropertyKey ? {
+    [P in T]: V;
+} : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? Partial<Record<T[number], V>> : never;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * @param data - An array of keys of the output object. All items in the array
+ * would be keys in the output array.
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(data, mapper);
+ * @example
+ *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataFirst
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number]) => V): Simplify<FromKeys<T, V>>;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(mapper)(data);
+ * @example
+ *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataLast
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number]) => V): (data: T) => Simplify<FromKeys<T, V>>;
+
+type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [
+    key: Key,
+    value: Value
+];
+type Strict$2 = <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})
+ *   P.pipe(
+ *     [['a', 'b'], ['c', 'd']],
+ *     P.fromPairs,
+ *   ); // => {a: 'b', c: 'd'} (type: Record<string, string>)
+ *   P.pipe(
+ *     ['a', 1] as const,
+ *     P.fromPairs.strict,
+ *   ); // => {a: 1} (type: {a: 1})
+ * @category Object
+ * @strict
+ * @dataFirst
+ */
+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$2;
+}
+
+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.
+ *
+ * @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>;
+
+type Strict$1 = <T extends object>(data: T) => Keys<T>;
+type Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;
+type ArrayKeys<T extends IterableContainer> = {
+    -readonly [Index in keyof T]: Index extends number | string ? `${IsIndexAfterSpread<T, Index> extends true ? number : Index}` : never;
+};
+type IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = 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<T> = T extends Record<PropertyKey, never> ? [] : Array<`${Exclude<keyof T, symbol>}`>;
+/**
+ * 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.keys.strict({ a: 'x', b: 'y', 5: 'z' } as const ) // => ['a', 'b', '5'], typed Array<'a' | 'b' | '5'>
+ *    P.pipe(['x', 'y', 'z'], P.keys) // => ['0', '1', '2']
+ *    P.pipe({ a: 'x', b: 'y', c: 'z' }, P.keys) // => ['a', 'b', 'c']
+ *    P.pipe(
+ *      { a: 'x', b: 'y', c: 'z' },
+ *      P.keys,
+ *      P.first(),
+ *    ) // => 'a'
+ *    P.pipe({ a: 'x', b: 'y', 5: 'z' } as const, P.keys.strict) // => ['a', 'b', '5'], typed Array<'a' | 'b' | '5'>
+ * @pipeable
+ * @strict
+ * @category Object
+ * @dataFirst
+ */
+declare function keys(source: ArrayLike<unknown> | Readonly<Record<PropertyKey, unknown>>): Array<string>;
+declare namespace keys {
+    const strict: Strict$1;
+}
+
+/**
+ * Maps keys of `object` and keeps the same values.
+ * @param data 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 PropertyKey>(data: T, fn: (key: keyof T, value: Required<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 PropertyKey>(fn: (key: keyof T, value: Required<T>[keyof T]) => S): (data: T) => Record<S, T[keyof T]>;
+
+/**
+ * Maps values of `object` and keeps the same keys.
+ * @param data 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, unknown>, S>(data: T, fn: (value: T[ObjectKeys$1<T>], key: ObjectKeys$1<T>) => S): Record<ObjectKeys$1<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, unknown>, S>(fn: (value: T[keyof T], key: keyof T) => S): (data: T) => Record<ObjectKeys$1<T>, S>;
+
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param data - The destination object, serving as the basis for the merge.
+ * Properties from this object are included in the new object, but will be
+ * overwritten by properties from the source object with matching keys.
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    R.merge(data, source)
+ * @example
+ *    R.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<T, Source>(data: T, source: Source): Merge<T, Source>;
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    R.merge(source)(data)
+ * @example
+ *    R.pipe(
+ *      { x: 1, y: 2 },
+ *      R.merge({ y: 10, z: 2 }),
+ *    ); // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
+
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns - The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns - The merged object.
+ * @signature
+ *    P.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(source: Source): (target: Destination) => MergeDeep<Destination, Source>;
+
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ * @param propNames the property names
+ * @signature
+ *    P.omit(propNames)(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<T extends object, K extends keyof T>(propNames: ReadonlyArray<K>): (data: T) => 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(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 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 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 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<T extends object, K extends keyof T>(names: ReadonlyArray<K>): (object: T) => Pick<T, K>;
+/**
+ * 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 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;
+
+/**
+ * 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 = bigint | boolean | number | string;
+/**
+ * @hidden
+ */
+type NarrowRaw<A> = {
+    [K in keyof A]: A[K] extends (...args: ReadonlyArray<unknown>) => unknown ? A[K] : NarrowRaw<A[K]>;
+} | (A extends [] ? [] : never) | (A extends Narrowable ? A : never);
+/**
+ * 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>>;
+
+type Path<Obj, Prefix extends Array<PropertyKey> = []> = Obj extends Primitive ? Prefix : Obj extends Array<infer Item> ? Path<Item, [...Prefix, number]> | Prefix : PathsOfObject<Obj, Prefix> | 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 = boolean | null | number | string | symbol | undefined;
+
+/**
+ * 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 path the property name
+ * @param value the value to set
+ * @signature
+ *    P.setPath(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_(data: unknown, path: ReadonlyArray<PropertyKey>, value: unknown): unknown;
+
+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 Pairs<T> = Array<{
+    [K in keyof T]-?: [key: K, value: Required<T>[K]];
+}[keyof T]>;
+interface Strict {
+    <T extends NonNullable<unknown>>(object: T): Pairs<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]>
+ *    P.pipe(
+ *      { a: 1, b: 2, c: 3 },
+ *      toPairs,
+ *    ); // => [['a', 1], ['b', 2], ['c', 3]]
+ *    P.pipe(
+ *      { a: 1 } as const,
+ *      toPairs.strict,
+ *    ); // => [['a', 1]] typed Array<['a', 1]>
+ * @strict
+ * @category Object
+ * @dataFirst
+ */
+declare function toPairs<T>(object: Readonly<Record<string, T>>): Array<[string, T]>;
+declare namespace toPairs {
+    const strict: Strict;
+}
+
+/**
+ * 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
+ */
+type Values<T extends object> = T extends [] | ReadonlyArray<unknown> ? Array<T[number]> : Array<T[keyof T]>;
+declare function values<T extends object>(source: T): Values<T>;
+
+type Splitter = '.' | '/' | '_' | '-';
+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 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 CapitalizedWords<T extends ReadonlyArray<string>, Accumulator extends string = '', Normalize extends boolean | undefined = false> = T extends readonly [infer F extends string, ...infer R extends Array<string>] ? CapitalizedWords<R, `${Accumulator}${Capitalize<Normalize extends true ? Lowercase<F> : F>}`, Normalize> : Accumulator;
+type JoinLowercaseWords<T extends ReadonlyArray<string>, Joiner extends string, Accumulator extends string = ''> = T extends readonly [infer F extends string, ...infer R extends Array<string>] ? Accumulator extends '' ? JoinLowercaseWords<R, Joiner, `${Accumulator}${Lowercase<F>}`> : JoinLowercaseWords<R, Joiner, `${Accumulator}${Joiner}${Lowercase<F>}`> : Accumulator;
+type LastOfArray<T extends Array<any>> = T extends [...any, infer R] ? R : never;
+type RemoveLastOfArray<T extends Array<any>> = T extends [...infer F, any] ? F : never;
+interface CaseOptions {
+    normalize?: boolean;
+}
+type SplitByCase<T, Separator extends string = Splitter, Accumulator extends Array<unknown> = []> = string extends Separator ? Array<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 '' ? [] : Array<string> : Accumulator;
+type JoinByCase<T, Joiner extends string> = string extends T ? string : Array<string> extends T ? string : T extends string ? SplitByCase<T> extends ReadonlyArray<string> ? JoinLowercaseWords<SplitByCase<T>, Joiner> : never : T extends ReadonlyArray<string> ? JoinLowercaseWords<T, Joiner> : never;
+type PascalCase<T, Normalize extends boolean | undefined = false> = string extends T ? string : Array<string> extends T ? string : T extends string ? SplitByCase<T> extends ReadonlyArray<string> ? CapitalizedWords<SplitByCase<T>, '', Normalize> : never : T extends ReadonlyArray<string> ? CapitalizedWords<T, '', Normalize> : never;
+type CamelCase<T, Normalize extends boolean | undefined = false> = string extends T ? string : Array<string> extends T ? string : Uncapitalize<PascalCase<T, Normalize>>;
+type KebabCase<T extends ReadonlyArray<string> | string, Joiner extends string = '-'> = JoinByCase<T, Joiner>;
+type SnakeCase<T extends ReadonlyArray<string> | string> = JoinByCase<T, '_'>;
+type TrainCase<T, Normalize extends boolean | undefined = false, Joiner extends string = '-'> = string extends T ? string : Array<string> extends T ? string : T extends string ? SplitByCase<T> extends ReadonlyArray<string> ? CapitalizedWords<SplitByCase<T>, Joiner> : never : T extends ReadonlyArray<string> ? CapitalizedWords<T, Joiner, Normalize> : never;
+type FlatCase<T extends ReadonlyArray<string> | string, Joiner extends string = ''> = JoinByCase<T, Joiner>;
+
+declare function isUppercase(char?: string): boolean | undefined;
+declare function splitByCase<T extends string>(str: T): SplitByCase<T>;
+declare function splitByCase<T extends string, Separator extends ReadonlyArray<string>>(str: T, separators: Separator): SplitByCase<T, Separator[number]>;
+declare function toUpperFirst<S extends string>(str: S): Capitalize<S>;
+declare function toLowerFirst<S extends string>(str: S): Uncapitalize<S>;
+declare function toPascalCase(): '';
+declare function toPascalCase<T extends ReadonlyArray<string> | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: CaseOptions): PascalCase<T, UserCaseOptions['normalize']>;
+declare function toCamelCase(): '';
+declare function toCamelCase<T extends ReadonlyArray<string> | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): CamelCase<T, UserCaseOptions['normalize']>;
+declare function toKebabCase(): '';
+declare function toKebabCase<T extends ReadonlyArray<string> | string>(str: T): KebabCase<T>;
+declare function toKebabCase<T extends ReadonlyArray<string> | string, Joiner extends string>(str: T, joiner: Joiner): KebabCase<T, Joiner>;
+declare function toSnakeCase(): '';
+declare function toSnakeCase<T extends ReadonlyArray<string> | string>(str: T): SnakeCase<T>;
+declare function toFlatCase(): '';
+declare function toFlatCase<T extends ReadonlyArray<string> | string>(str: T): FlatCase<T>;
+declare function toTrainCase(): '';
+declare function toTrainCase<T extends ReadonlyArray<string> | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): TrainCase<T, UserCaseOptions['normalize']>;
+declare function toTitleCase(): '';
+declare function toTitleCase<T extends ReadonlyArray<string> | string, UserCaseOptions extends CaseOptions = CaseOptions>(str: T, opts?: UserCaseOptions): TrainCase<T, UserCaseOptions['normalize'], ' '>;
+
+/**
+ * Returns human readable file size.
+ * @param bytes the file size in bytes
+ * @param base the base (1000 or 1024)
+ * @signature
+ *  P.humanReadableFileSize(bytes, base)
+ * @example
+ *  P.humanReadableFileSize(1000) // => '1.0 kB'
+ *  P.humanReadableFileSize(2097152, 1024) // => '2.0 Mib'
+ * @category String
+ */
+declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
+
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ *
+ * @param length the length of the random string
+ * @returns the random string
+ * @signature
+ *   P.randomString(length)
+ * @example
+ *   P.randomString(5) // => aB92J
+ *   P.pipe(5, P.randomString) // => aB92J
+ * @category String
+ * @dataFirst
+ */
+declare function randomString(length: number): string;
+
+/**
+ * Turn any string into a URL/DOM safe string.
+ * @param str the string to slugify
+ * @signature
+ *  P.slugify(str)
+ * @example
+ *  P.slugify('FooBar') // => 'foobar'
+ *  P.slugify('This!-is*&%#@^up!') // => 'this-is-up'
+ * @category String
+ */
+declare function slugify(str: string): 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: unknown): string;
+
+declare const isBrowser: boolean;
+
+export { type Joined, KEY_CODES, type LazyEvaluator, type StringToPath, add, addProp, allPass, anyPass, ceil, chunk, clamp, clone, concat, conditional, createPipe, debounce, differenceWith, divide, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flatMap, flatMapToObj, flatten, flattenDeep, floor, forEach, forEachObj, fromKeys, fromPairs, groupBy, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersectionWith, invert, isArray, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isError, isFunction, isIncludedIn, isNil, isNonNull, isNot, isNumber, isObject, isPromise, isString, isSymbol, isTruthy, isUppercase, join, keys, last, length, map, mapKeys, mapToObj, mapValues, maxBy, meanBy, merge, mergeAll, mergeDeep, minBy, multiply, noop, nthBy, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, prop, purry, randomString, range, rankBy, reduce, reject, reverse, round, sample, set, setPath, setPath_, shuffle, sleep, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, splice, splitAt, splitByCase, splitWhen, stringToPath, subtract, sumBy, swapIndices, swapProps, take, takeFirstBy, takeWhile, times, toCamelCase, toFlatCase, toKebabCase, toLowerFirst, toPairs, toPascalCase, toSnakeCase, toTitleCase, toTrainCase, toUpperFirst, type, uniq, uniqBy, uniqWith, values, zip, zipObj, zipWith };