es-toolkit 1.48.1 → 1.49.0

package/dist/fp/array/keyBy.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/keyBy.d.ts
+/**
+ * Creates a function that indexes values by a derived key.
+ *
+ * The key selector receives each value, index, and full input array. When multiple values
+ * produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the selector.
+ * @param getKey - Called with each value, index, and array to produce an object key.
+ * @returns A function that maps a readonly array to an object keyed by the derived keys.
+ *
+ * @example
+ * import { keyBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+ * // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+ */
+declare function keyBy<T, K extends PropertyKey>(getKey: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, T>;
+//#endregion
+export { keyBy };

package/dist/fp/array/keyBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/keyBy.d.ts
+/**
+ * Creates a function that indexes values by a derived key.
+ *
+ * The key selector receives each value, index, and full input array. When multiple values
+ * produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The property-key type produced by the selector.
+ * @param getKey - Called with each value, index, and array to produce an object key.
+ * @returns A function that maps a readonly array to an object keyed by the derived keys.
+ *
+ * @example
+ * import { keyBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+ * // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+ */
+declare function keyBy<T, K extends PropertyKey>(getKey: (item: T, index: number, array: readonly T[]) => K): (array: readonly T[]) => Record<K, T>;
+//#endregion
+export { keyBy };

package/dist/fp/array/keyBy.js

@@ -0,0 +1,26 @@
+const require_keyBy = require("../../array/keyBy.js");
+//#region src/fp/array/keyBy.ts
+/**
+* Creates a function that indexes values by a derived key.
+*
+* The key selector receives each value, index, and full input array. When multiple values
+* produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the selector.
+* @param getKey - Called with each value, index, and array to produce an object key.
+* @returns A function that maps a readonly array to an object keyed by the derived keys.
+*
+* @example
+* import { keyBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+* // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+*/
+function keyBy(getKey) {
+	return function(array) {
+		return require_keyBy.keyBy(array, getKey);
+	};
+}
+//#endregion
+exports.keyBy = keyBy;

package/dist/fp/array/keyBy.mjs

@@ -0,0 +1,26 @@
+import { keyBy as keyBy$1 } from "../../array/keyBy.mjs";
+//#region src/fp/array/keyBy.ts
+/**
+* Creates a function that indexes values by a derived key.
+*
+* The key selector receives each value, index, and full input array. When multiple values
+* produce the same key, the last value wins, matching the main {@link keyBy} behavior.
+*
+* @template T - The type of elements in the array.
+* @template K - The property-key type produced by the selector.
+* @param getKey - Called with each value, index, and array to produce an object key.
+* @returns A function that maps a readonly array to an object keyed by the derived keys.
+*
+* @example
+* import { keyBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 'a', value: 1 }, { id: 'b', value: 2 }], keyBy(item => item.id));
+* // => { a: { id: 'a', value: 1 }, b: { id: 'b', value: 2 } }
+*/
+function keyBy(getKey) {
+	return function(array) {
+		return keyBy$1(array, getKey);
+	};
+}
+//#endregion
+export { keyBy };

package/dist/fp/array/last.d.mts

@@ -0,0 +1,35 @@
+//#region src/fp/array/last.d.ts
+/**
+ * Creates a function that returns the last element of a non-empty array.
+ *
+ * This overload preserves the non-empty tuple guarantee: the returned function
+ * always returns T when the piped array has at least one element.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a non-empty readonly array to its last element.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3] as const, last());
+ * // => 3
+ */
+declare function last<T>(): (array: readonly [...T[], T]) => T;
+/**
+ * Creates a function that returns the last element of an array, or undefined.
+ *
+ * Empty arrays return undefined, matching the main {@link last} behavior. Use
+ * the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its last element, or undefined.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as number[], last());
+ * // => undefined
+ */
+declare function last<T>(): (array: readonly T[]) => T | undefined;
+//#endregion
+export { last };

package/dist/fp/array/last.d.ts

@@ -0,0 +1,35 @@
+//#region src/fp/array/last.d.ts
+/**
+ * Creates a function that returns the last element of a non-empty array.
+ *
+ * This overload preserves the non-empty tuple guarantee: the returned function
+ * always returns T when the piped array has at least one element.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a non-empty readonly array to its last element.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3] as const, last());
+ * // => 3
+ */
+declare function last<T>(): (array: readonly [...T[], T]) => T;
+/**
+ * Creates a function that returns the last element of an array, or undefined.
+ *
+ * Empty arrays return undefined, matching the main {@link last} behavior. Use
+ * the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its last element, or undefined.
+ *
+ * @example
+ * import { last, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as number[], last());
+ * // => undefined
+ */
+declare function last<T>(): (array: readonly T[]) => T | undefined;
+//#endregion
+export { last };

package/dist/fp/array/last.js

@@ -0,0 +1,9 @@
+const require_last = require("../../array/last.js");
+//#region src/fp/array/last.ts
+function last() {
+	return function(array) {
+		return require_last.last(array);
+	};
+}
+//#endregion
+exports.last = last;

package/dist/fp/array/last.mjs

@@ -0,0 +1,9 @@
+import { last as last$1 } from "../../array/last.mjs";
+//#region src/fp/array/last.ts
+function last() {
+	return function(array) {
+		return last$1(array);
+	};
+}
+//#endregion
+export { last };

package/dist/fp/array/length.d.mts

@@ -0,0 +1,18 @@
+//#region src/fp/array/length.d.ts
+/**
+ * Creates a function that returns the length of an array.
+ *
+ * Use it with {@link pipe} when a pipeline should end with the number of input values.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its length.
+ *
+ * @example
+ * import { length, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], length());
+ * // => 3
+ */
+declare function length<T>(): (array: readonly T[]) => number;
+//#endregion
+export { length };

package/dist/fp/array/length.d.ts

@@ -0,0 +1,18 @@
+//#region src/fp/array/length.d.ts
+/**
+ * Creates a function that returns the length of an array.
+ *
+ * Use it with {@link pipe} when a pipeline should end with the number of input values.
+ *
+ * @template T - The type of elements in the array.
+ * @returns A function that maps a readonly array to its length.
+ *
+ * @example
+ * import { length, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], length());
+ * // => 3
+ */
+declare function length<T>(): (array: readonly T[]) => number;
+//#endregion
+export { length };

package/dist/fp/array/length.js

@@ -0,0 +1,22 @@
+//#region src/fp/array/length.ts
+/**
+* Creates a function that returns the length of an array.
+*
+* Use it with {@link pipe} when a pipeline should end with the number of input values.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its length.
+*
+* @example
+* import { length, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], length());
+* // => 3
+*/
+function length() {
+	return function(array) {
+		return array.length;
+	};
+}
+//#endregion
+exports.length = length;

package/dist/fp/array/length.mjs

@@ -0,0 +1,22 @@
+//#region src/fp/array/length.ts
+/**
+* Creates a function that returns the length of an array.
+*
+* Use it with {@link pipe} when a pipeline should end with the number of input values.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its length.
+*
+* @example
+* import { length, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], length());
+* // => 3
+*/
+function length() {
+	return function(array) {
+		return array.length;
+	};
+}
+//#endregion
+export { length };

package/dist/fp/array/map.d.mts

@@ -0,0 +1,27 @@
+//#region src/fp/array/map.d.ts
+/**
+ * Creates a function that builds a new array by calling `callback` on every
+ * element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element, so a trailing
+ * `take` can terminate the walk early without mapping the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; its return
+ *   value becomes the corresponding element of the output array.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, map } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+ *
+ * @example
+ * // The index is available as the second argument.
+ * pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (array: readonly T[]) => U[];
+//#endregion
+export { map };

package/dist/fp/array/map.d.ts

@@ -0,0 +1,27 @@
+//#region src/fp/array/map.d.ts
+/**
+ * Creates a function that builds a new array by calling `callback` on every
+ * element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+ *
+ * The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+ * with adjacent lazy functions and runs element-by-element, so a trailing
+ * `take` can terminate the walk early without mapping the rest of the input.
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param callback - Called with `(value, index)` for each element; its return
+ *   value becomes the corresponding element of the output array.
+ * @returns A function that maps a `readonly T[]` to a new `U[]`.
+ *
+ * @example
+ * import { pipe, map } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+ *
+ * @example
+ * // The index is available as the second argument.
+ * pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+ */
+declare function map<T, U>(callback: (value: T, index: number) => U): (array: readonly T[]) => U[];
+//#endregion
+export { map };

package/dist/fp/array/map.js

@@ -0,0 +1,36 @@
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/map.ts
+/**
+* Creates a function that builds a new array by calling `callback` on every
+* element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+*
+* The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+* with adjacent lazy functions and runs element-by-element, so a trailing
+* `take` can terminate the walk early without mapping the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; its return
+*   value becomes the corresponding element of the output array.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, map } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+*
+* @example
+* // The index is available as the second argument.
+* pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+*/
+function map(callback) {
+	function mapEager(array) {
+		return array.map(callback);
+	}
+	const mapLazy = require_lazy.createLazyFunction((value, index, emit) => {
+		emit(callback(value, index));
+	});
+	return require_lazy.combineEagerAndLazyFunctions(mapEager, mapLazy);
+}
+//#endregion
+exports.map = map;

package/dist/fp/array/map.mjs

@@ -0,0 +1,35 @@
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/map.ts
+/**
+* Creates a function that builds a new array by calling `callback` on every
+* element, equivalent to `Array.prototype.map`. Use it with {@link pipe}.
+*
+* The returned function is **lazy-capable**: inside a {@link pipe} it is fused
+* with adjacent lazy functions and runs element-by-element, so a trailing
+* `take` can terminate the walk early without mapping the rest of the input.
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param callback - Called with `(value, index)` for each element; its return
+*   value becomes the corresponding element of the output array.
+* @returns A function that maps a `readonly T[]` to a new `U[]`.
+*
+* @example
+* import { pipe, map } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], map(x => x * 2)); // => [2, 4, 6]
+*
+* @example
+* // The index is available as the second argument.
+* pipe([10, 20, 30], map((value, index) => value + index)); // => [10, 21, 32]
+*/
+function map(callback) {
+	function mapEager(array) {
+		return array.map(callback);
+	}
+	return combineEagerAndLazyFunctions(mapEager, createLazyFunction((value, index, emit) => {
+		emit(callback(value, index));
+	}));
+}
+//#endregion
+export { map };

package/dist/fp/array/maxBy.d.mts

@@ -0,0 +1,37 @@
+//#region src/fp/array/maxBy.d.ts
+/**
+ * Creates a function that returns the element with the maximum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the maximum element.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, maxBy(item => item.score));
+ * // => { score: 20 }
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the maximum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the maximum element, or undefined.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, maxBy(item => item.score));
+ * // => undefined
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { maxBy };

package/dist/fp/array/maxBy.d.ts

@@ -0,0 +1,37 @@
+//#region src/fp/array/maxBy.d.ts
+/**
+ * Creates a function that returns the element with the maximum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the maximum element.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, maxBy(item => item.score));
+ * // => { score: 20 }
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the maximum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link maxBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the maximum element, or undefined.
+ *
+ * @example
+ * import { maxBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, maxBy(item => item.score));
+ * // => undefined
+ */
+declare function maxBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { maxBy };

package/dist/fp/array/maxBy.js

@@ -0,0 +1,9 @@
+const require_maxBy = require("../../array/maxBy.js");
+//#region src/fp/array/maxBy.ts
+function maxBy(getValue) {
+	return function(array) {
+		return require_maxBy.maxBy(array, getValue);
+	};
+}
+//#endregion
+exports.maxBy = maxBy;

package/dist/fp/array/maxBy.mjs

@@ -0,0 +1,9 @@
+import { maxBy as maxBy$1 } from "../../array/maxBy.mjs";
+//#region src/fp/array/maxBy.ts
+function maxBy(getValue) {
+	return function(array) {
+		return maxBy$1(array, getValue);
+	};
+}
+//#endregion
+export { maxBy };

package/dist/fp/array/minBy.d.mts

@@ -0,0 +1,37 @@
+//#region src/fp/array/minBy.d.ts
+/**
+ * Creates a function that returns the element with the minimum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the minimum element.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, minBy(item => item.score));
+ * // => { score: 10 }
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the minimum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the minimum element, or undefined.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, minBy(item => item.score));
+ * // => undefined
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { minBy };

package/dist/fp/array/minBy.d.ts

@@ -0,0 +1,37 @@
+//#region src/fp/array/minBy.d.ts
+/**
+ * Creates a function that returns the element with the minimum selected number from a non-empty array.
+ *
+ * If the selector returns NaN, the element that produced NaN is returned, matching
+ * the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a non-empty readonly array to the minimum element.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ score: 10 }, { score: 20 }] as const, minBy(item => item.score));
+ * // => { score: 10 }
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly [T, ...T[]]) => T;
+/**
+ * Creates a function that returns the element with the minimum selected number.
+ *
+ * Empty arrays return undefined. If the selector returns NaN, the element that
+ * produced NaN is returned, matching the main {@link minBy} behavior.
+ *
+ * @template T - The type of elements in the array.
+ * @param getValue - Selects a numeric value from each element, index, and array.
+ * @returns A function that maps a readonly array to the minimum element, or undefined.
+ *
+ * @example
+ * import { minBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([] as Array<{ score: number }>, minBy(item => item.score));
+ * // => undefined
+ */
+declare function minBy<T>(getValue: (element: T, index: number, array: readonly T[]) => number): (array: readonly T[]) => T | undefined;
+//#endregion
+export { minBy };

package/dist/fp/array/minBy.js

@@ -0,0 +1,9 @@
+const require_minBy = require("../../array/minBy.js");
+//#region src/fp/array/minBy.ts
+function minBy(getValue) {
+	return function(array) {
+		return require_minBy.minBy(array, getValue);
+	};
+}
+//#endregion
+exports.minBy = minBy;

package/dist/fp/array/minBy.mjs

@@ -0,0 +1,9 @@
+import { minBy as minBy$1 } from "../../array/minBy.mjs";
+//#region src/fp/array/minBy.ts
+function minBy(getValue) {
+	return function(array) {
+		return minBy$1(array, getValue);
+	};
+}
+//#endregion
+export { minBy };

package/dist/fp/array/orderBy.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/orderBy.d.ts
+/**
+ * Creates a function that sorts objects by criteria and order directions.
+ *
+ * Criteria can be object keys or selector functions. The returned function does not mutate
+ * the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+ *
+ * @template T - The object type in the array.
+ * @param criteria - Keys or selector functions used for comparison.
+ * @param orders - Sort directions corresponding to the criteria.
+ * @returns A function that maps a readonly array to a sorted copy.
+ *
+ * @example
+ * import { orderBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+ * // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+ */
+declare function orderBy<T extends object>(criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): (array: readonly T[]) => T[];
+//#endregion
+export { orderBy };

package/dist/fp/array/orderBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/orderBy.d.ts
+/**
+ * Creates a function that sorts objects by criteria and order directions.
+ *
+ * Criteria can be object keys or selector functions. The returned function does not mutate
+ * the input array; it returns a sorted copy following the main {@link orderBy} behavior.
+ *
+ * @template T - The object type in the array.
+ * @param criteria - Keys or selector functions used for comparison.
+ * @param orders - Sort directions corresponding to the criteria.
+ * @returns A function that maps a readonly array to a sorted copy.
+ *
+ * @example
+ * import { orderBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ name: 'a', age: 2 }, { name: 'b', age: 1 }], orderBy(['age'], ['asc']));
+ * // => [{ name: 'b', age: 1 }, { name: 'a', age: 2 }]
+ */
+declare function orderBy<T extends object>(criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): (array: readonly T[]) => T[];
+//#endregion
+export { orderBy };