@vielzeug/toolkit 1.0.11

package/dist/index.d.ts

@@ -0,0 +1,2278 @@
+/**
+ * Aggregates an array of objects into an object based on a key generated by a selector function.
+ *
+ * @example
+ * ```ts
+ * const data = [{ a: 1 }, { a: 2 }, { a: 1 }];
+ * aggregate(data, 'a') // { '1': { a: 1 }, '2': { a: 2 } };
+ * ```
+ *
+ * @param array - The array to key.
+ * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.
+ *
+ * @returns An object with keys as the generated values and values as the last element responsible for generating the key.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function aggregate<T, K extends keyof T, R extends T[K] extends string ? T[K] : never>(array: T[], selector: Selector<T>): Record<R, T>;
+
+export declare namespace aggregate {
+    var fp: boolean;
+}
+
+/**
+ * Either adds or removes an item from an array, based on whether it already exists in the array.
+ *
+ * @example
+ * ```ts
+ * alternate([1, 2, 3], 4) // [1, 2, 3, 4]
+ * alternate([1, 2, 3], 2) // [1, 3]
+ *
+ * alternate(
+ *   [{ id: 1 }, { id: 2 }],
+ *   { id: 3 },
+ *   (obj) => obj.id,
+ *   { strategy: 'prepend' }
+ * ) // [{ id: 3 }, { id: 1 }, { id: 2 }]
+ * ```
+ *
+ * @param array - The array to modify.
+ * @param item - The item to add or remove.
+ * @param selector - A function to determine the uniqueness of the item.
+ * @param [options] - Options for the alternate operation.
+ * @param [options.strategy] - The strategy to use when adding the item ('prepend' or 'append').
+ *
+ * @returns A new array with the item added or removed.
+ */
+export declare function alternate<T>(array: T[], item: T, selector?: (item: T) => Primitive, options?: {
+    strategy?: 'prepend' | 'append';
+}): T[];
+
+export declare namespace alternate {
+    var fp: boolean;
+}
+
+export declare type ArgType = 'array' | 'boolean' | 'date' | 'error' | 'function' | 'map' | 'nan' | 'null' | 'number' | 'object' | 'promise' | 'regexp' | 'set' | 'string' | 'symbol' | 'weakmap' | 'weakset' | 'undefined';
+
+/**
+ * Asserts that the condition is true. If the condition is false, it throws an error
+ * with the provided message or logs a warning in soft mode.
+ *
+ * @example
+ * ```ts
+ * assert(Array.isArray([])); // Does nothing
+ * assert(typeof foo === 'string', 'This is an error message'); // Throws an error
+ * assert(x > 0, 'x must be positive', { args: { x } }); // Throws with argument details
+ * ```
+ *
+ * @param condition - The condition to assert, or an array of conditions.
+ * @param [message] - The error message to throw. Default is 'Assertion failed'.
+ * @param options - Assertion options.
+ * @param [options.type] - The error class to throw (default: `Error`).
+ * @param [options.args] - Additional debugging information (e.g., variable values).
+ * @param [options.bypass] - If `true`, logs a warning instead of throwing an error.
+ *
+ * @throws {Error} If the condition is false and `bypass` is not set to `true`.
+ */
+declare function assert_2(condition: boolean | boolean[], message?: string, { type, args, bypass }?: {
+    type?: ErrorConstructor;
+    args?: Obj;
+    bypass?: boolean;
+}): void;
+export { assert_2 as assert }
+
+/**
+ * Asserts that the specified keys are present in the params object and are not empty strings.
+ *
+ * @example
+ * ```ts
+ * const params = { id: '123', name: '' };
+ * assertParams(params, ['id']); // Does nothing
+ * assertParams(params, ['id', 'name'], 'UserUpdate'); // Throws: Missing required parameter: "name" in "UserUpdate"
+ * ```
+ *
+ * @param params - The object containing the parameters to check.
+ * @param keys - An array of keys that must be present and non-empty in the params object.
+ * @param [name] - An optional name for the context of the assertion (e.g., function name).
+ * @param [options] - Assertion options.
+ * @param [options.type] - The error class to throw (default: `Error`).
+ * @param [options.bypass] - If `true`, logs a warning instead of throwing an error.
+ *
+ * @throws {Error} If any of the required keys are missing or are empty strings.
+ */
+export declare function assertParams<T extends object, K extends keyof T>(params: T, keys: K[], name?: string, options?: {
+    type?: ErrorConstructor;
+    bypass?: boolean;
+}): asserts params is T & Required<Pick<T, K>>;
+
+declare type AsyncCallback<R, T> = (prev: R, curr: T, index: number, array: T[]) => Promise<R>;
+
+/**
+ * Attempts to execute a function with advanced error handling and retry logic.
+ *
+ * @example
+ * ```ts
+ * const unreliableFunction = async () => {
+ *   if (Math.random() < 0.7) throw new Error ('Random failure');
+ *   return 'Success!';
+ * };
+ *
+ * await attempt(
+ *   unreliableFunction,
+ *   { retries: 3, silent: false, timeout: 5000 }); // Success! (or undefined if all attempts failed)
+ * ```
+ *
+ * @param fn - The function to be executed.
+ * @param [options] - Configuration options for the attempt.
+ * @param [options.identifier] - Custom identifier for logging purposes.
+ * @param [options.retries=0] - Number of retry attempts if the function fails.
+ * @param [options.silent=false] - If true, suppresses error logging.
+ * @param [options.timeout=7000] - Timeout in milliseconds for function execution.
+ *
+ * @returns The result of the function or undefined if it failed.
+ */
+export declare function attempt<T extends Fn, R = Awaited<ReturnType<T>>>(fn: T, { silent, retries, timeout, identifier }?: AttemptOptions): Promise<R | undefined>;
+
+declare type AttemptOptions = {
+    identifier?: string;
+    retries?: number;
+    silent?: boolean;
+    timeout?: number;
+};
+
+/**
+ * Calculates the average of an array of numbers or dates.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * average(arr); // 3
+ * average(arr, (num) => num * 2); // 6
+ * average(arr, (num) => new Date(Date.now() + 1000 * 60 * 60 * 24 * num); // Date object representing 3 days from now
+ * ```
+ *
+ * @param array - The array of numbers or dates to average.
+ * @param callback - (optional) A callback function to map the values.
+ * @returns The average of the numbers or dates in the array.
+ */
+export declare function average<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined;
+
+/**
+ * Boils down an array to a single value by applying a callback function to each pair of elements.
+ *
+ * @example
+ * ```ts
+ * boil([1, 2, 3]) // 3
+ * boil([1, 2, 3], (a, b) => a > b ? a : b) // 3
+ * boil([1, 2, 3], (a, b) => a + b) // 6
+ * boil([{ a: 1 }, { a: 2 }, { a: 3 }], (a, b) => ({ a: a.a + b.a })) // { a: 6 }
+ * boil([], (a, b) => a + b) // undefined
+ * boil([1], (a, b) => a + b) // 1
+ * ```
+ *
+ * @param array - The array to be boiled down.
+ * @param callback - The function to invoke for each pair of elements in the array.
+ *
+ * @return The boiled down value, or `undefined` if the array is empty.
+ */
+export declare function boil<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined;
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: - */
+export declare type Callback<T = any, R = any> = (value: T, index: number, array: T[]) => R;
+
+declare type Callback_2<R, T> = SyncCallback<R, T> | AsyncCallback<R, T>;
+
+export declare type CallbackAsync<T = any, R = any> = (value: T, index: number, array: T[]) => Promise<R>;
+
+export declare type CallbackDynamic<T = any, R = any> = (value: T, index: number, array: T[]) => R | Promise<R>;
+
+/**
+ * Converts a string to camel case.
+ *
+ * @example
+ * ```ts
+ * const text = 'hello world';
+ * camelCase(text); // 'helloWorld'
+ * ```
+ *
+ * @param str - The string to convert.
+ * @returns The converted string.
+ */
+export declare function camelCase(str: string): string;
+
+/**
+ * Splits an array or string into chunks of a specified size.
+ *
+ * @example
+ * ```ts
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * chunk("hello", 2) // ["he", "ll", "o"]
+ * chunk("hello", 2, { overlap: true }) // [" h", "he", "el", "ll", "lo", "o "]
+ * ```
+ *
+ * @param input - The input array or string to be chunked.
+ * @param size - The size of each chunk.
+ * @param [options] - Additional options for chunking.
+ * @param [options.overlap] -
+ * @param [options.pad] -
+ *
+ * @returns An array of chunks.
+ *
+ * @throws {RangeError} If the chunk size is invalid.
+ * @throws {TypeError} If the input type is invalid.
+ */
+export declare function chunk<T>(input: T[] | string, size?: number, options?: ChunkOptions): ChunkResult<T>;
+
+declare type ChunkOptions = {
+    overlap?: boolean;
+    pad?: string;
+};
+
+declare type ChunkResult<T> = (T extends string ? string : T[])[];
+
+/**
+ * The `clamp` function restricts a number to be within a specified range.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 1, 10) // 5
+ * clamp(0, 1, 10) // 1
+ * clamp(15, 1, 10) // 10
+ * ```
+ *
+ * @param n - The number to be clamped.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ *
+ * @returns The clamped number.
+ */
+export declare function clamp(n: number, min: number, max: number): number;
+
+/**
+ * Creates a deep copy of the provided data using the structuredClone algorithm.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: { c: 2 } };
+ * const dup = clone(obj);
+ *
+ * dup.b.c = 3;
+ * console.log(obj.b.c); // logs 2
+ * console.log(dup.b.c); // logs 3
+ * ```
+ *
+ * @param item - The data to clone.
+ *
+ * @returns A deep copy of the provided data.
+ */
+export declare function clone<T>(item: T): T;
+
+/**
+ * Removes falsy values from an array.
+ *
+ * @example
+ * ```ts
+ * const arr = [0, 1, false, 2, '', 3];
+ * compact(arr); // [1, 2, 3]
+ * ```
+ *
+ * @param array - The array to compact.
+ *
+ * @returns A new array with falsy values removed.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function compact<T>(array: T[]): NonNullable<T>[];
+
+/**
+ * Compares two values and returns:
+ * - 0 if they are equal
+ * - 1 if the first value is greater
+ * - -1 if the second value is greater
+ *
+ * @example
+ * ```ts
+ * compare('a', 'b'); // -1
+ * compare(1, 2); // -1
+ * compare(new Date('2023-01-01'), new Date('2023-01-02')); // -1
+ * compare('a', 'a'); // 0
+ * compare(1, 1); // 0
+ * compare(new Date('2023-01-01'), new Date('2023-01-01')); // 0
+ * ```
+ *
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ *
+ * @returns 0 if equal, 1 if the first value is greater, -1 if the second value is greater.
+ */
+export declare const compare: (a: any, b: any) => number;
+
+/**
+ * Compares two objects based on multiple selectors.
+ * The comparison is done in the order of the selectors provided.
+ * Each selector can be 'asc' for ascending or 'desc' for descending order.
+ *
+ * @example
+ * ```ts
+ * const compareByNameAndAge = compareBy<{ name: string; age: number }>({
+ *   name: 'asc',
+ *   age: 'desc',
+ * });
+ *
+ * const a = { name: 'Alice', age: 30 };
+ * const b = { name: 'Bob', age: 25 };
+ *
+ * console.log(compareByNameAndAge(a, b)); // -1 (Alice < Bob)
+ * ```
+ *
+ * @param selectors - An object where keys are properties to compare and values are 'asc' or 'desc'.
+ *
+ * @returns A comparison function that can be used with array sorting methods.
+ */
+export declare const compareBy: <T>(selectors: Partial<Record<keyof T, "asc" | "desc">>) => (a: T, b: T) => number;
+
+/**
+ * Composes multiple functions into a single function. It starts from the rightmost function and proceeds to the left.
+ *
+ * @example
+ * ```ts
+ * const add = (x) => x + 2;
+ * const multiply = (x) => x * 3;
+ * const subtract = (x) => x - 4;
+ * const composedFn = compose(subtract, multiply, add);
+ * composedFn(5); // ((5 + 2) * 3) - 4 = 17
+ * ```
+ *
+ * @example
+ * ```ts
+ * const square = async (x) => x * x;
+ * const add = async (x) => x + 2;
+ * const composedFn = compose(square, add);
+ * await composedFn(4); // (4 * 4) + 2 = 18
+ * ```
+ *
+ * @param fns - List of the functions to be composed.
+ *
+ * @returns A new function that is the composition of the input functions.
+ */
+export declare function compose<T extends FnDynamic[]>(...fns: T): ComposeReturn<T>;
+
+declare type ComposeReturn<T extends FnDynamic[]> = (...args: LastParameters<T>) => FirstReturnType<T> extends Promise<any> ? Promise<Awaited<FirstReturnType<T>>> : FirstReturnType<T>;
+
+declare type Config<T> = {
+    filterFn?: Predicate<T>;
+    limit?: number;
+    sortFn?: (a: T, b: T) => number;
+};
+
+/**
+ * Checks if a value is present in an array.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, { a: 1 }, 'hello'];
+ * const value = { a: 1 };
+ * contains(arr, value) // true;
+ * ```
+ *
+ * @param array - The array to check.
+ * @param value - The value to search for.
+ *
+ * @returns true if the value is present in the array, else false.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function contains<T>(array: T[], value: any): boolean;
+
+export declare namespace contains {
+    var fp: boolean;
+}
+
+declare type CurriedFunction<Params extends any[], R> = Params extends [infer A, ...infer Rest] ? (arg: A) => CurriedFunction<Rest, R> : R;
+
+/**
+ * Curries a function, allowing it to be called with partial arguments.
+ *
+ * @example
+ * ```ts
+ * const add = (a: number, b: number) => a + b;
+ * const curriedAdd = curry(add);
+ * curriedAdd(1)(2) // 3;
+ * ```
+ *
+ * @param fn - The function to curry.
+ *
+ * @returns A curried version of the function.
+ */
+export declare const curry: <T extends (...args: any[]) => any>(fn: T) => T extends (...args: infer P) => infer R ? CurriedFunction<P, R> : never;
+
+/**
+ * Creates a debounced function that delays invoking the provided function until after
+ * a specified wait time has elapsed since the last invocation.
+ *
+ * @example
+ * ```ts
+ * const debouncedLog = debounce(console.log, 1000);
+ *
+ * debouncedLog('Hello'); // Will log after 1 second if not called again
+ * debouncedLog('World'); // Resets the timer, will log 'World' after 1 second
+ * ```
+ *
+ * @param fn - The function to debounce.
+ * @param [delay=300] - - The number of milliseconds to delay invoking the function.
+ *
+ * @returns - A debounced function
+ */
+export declare function debounce<T extends Fn>(fn: T, delay?: number): (...args: Parameters<T>) => void;
+
+declare type DeepMerge<T, U> = T extends Obj ? U extends Obj ? {
+    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? DeepMerge<T[K], U[K]> : T[K] : K extends keyof U ? U[K] : never;
+} : U : U;
+
+/**
+ * Delays the execution of a function by a specified amount of time.
+ *
+ * @example
+ * ```ts
+ * const log = () => console.log('Hello, world!');
+ *
+ * delay(log, 1000); // logs 'Hello, world!' after 1 second
+ * ```
+ *
+ * @param fn - The function to be delayed.
+ * @param delay - The amount of time to delay the function execution, in milliseconds. Default is 700.
+ *
+ * @returns A Promise that resolves with the result of the function execution.
+ */
+export declare function delay<T extends Fn>(fn: T, delay?: number): Promise<any>;
+
+/**
+ * Computes the difference between two objects.
+ *
+ * @example
+ * ```ts
+ * const obj1 = { a: 1, b: 2, c: 3 };
+ * const obj2 = { b: 2, c: 3, d: 4 };
+ *
+ * diff(obj1, obj2); // { d: 4 }
+ * ```
+ *
+ * @param curr - The current object.
+ * @param prev - The previous object.
+ * @param [compareFn] - A custom function to compare values.
+ * @returns An object containing new/modified properties.
+ */
+export declare function diff<T extends Obj>(curr?: T, prev?: T, compareFn?: (a: unknown, b: unknown) => boolean): Partial<T>;
+
+/**
+ * “Draw” a random item from an array.
+ *
+ * @example
+ * ```ts
+ * draw([1, 2, 3]) // 3
+ * ```
+ *
+ * @param array - The array to draw from.
+ *
+ * @returns A random item from the array or `undefined` if the array is empty.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare const draw: <T>(array: T[]) => T | undefined;
+
+declare type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+
+/**
+ * Returns an array of a given object's own enumerable string-keyed property [key, value] pairs.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2, c: 3 };
+ * entries(obj); // logs [['a', 1], ['b', 2], ['c', 3]]
+ * ```
+ *
+ * @param item - The object whose properties are to be returned.
+ *
+ * @returns an array of the object's own enumerable string-keyed property [key, value] pairs.
+ */
+export declare function entries<T extends Obj>(item: T): Entries<T>;
+
+/**
+ * Checks if all elements in an array pass a predicate function.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * every(arr, isEven); // false
+ * ```
+ *
+ * @param array - The array to check.
+ * @param predicate - The predicate function to test each element.
+ *
+ * @returns true if all elements pass the predicate test, else false.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function every<T>(array: T[], predicate: Predicate<T>): boolean;
+
+export declare namespace every {
+    var fp: boolean;
+}
+
+export declare type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';
+
+/**
+ * Determines the expiry status of a given date.
+ *
+ * @param date - The date to check, as a string or Date object.
+ * @param days - Number of days before expiry to be considered "SOON" (default: 7).
+ * @returns
+ *   - 'EXPIRED' if the date is in the past,
+ *   - 'SOON' if the date is within the next `days`,
+ *   - 'LATER' if the date is further in the future,
+ *   - 'NEVER' if the year is >= 9999,
+ *   - 'UNKNOWN' if the date is invalid.
+ */
+export declare function expires(date: string | Date, days?: number): Expires;
+
+/**
+ * Filters an array based on a predicate function.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * filter(arr, isEven); // [2, 4]
+ * ```
+ *
+ * @param array - The array to filter.
+ * @param predicate - The predicate function to test each element.
+ *
+ * @returns A new array with elements that pass the predicate test.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function filter<T>(array: T[], predicate: Predicate<T>): T[];
+
+export declare namespace filter {
+    var fp: boolean;
+}
+
+/**
+ * Finds the first element in an array that satisfies a predicate function.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * find(arr, isEven); // 2
+ * find(arr, (num) => num > 5, 0); // 0
+ * find(arr, (num) => num > 5); // undefined
+ * ```
+ *
+ * @param array - The array to search through.
+ * @param predicate - A function that is called for each element in the array.
+ * @param [defaultValue] - (optional) value to return if no element satisfies the predicate.
+ *
+ * @return The first element in the array that satisfies the predicate, or the default value if none match.
+ */
+export declare function find<T>(array: T[], predicate: Predicate<T>, defaultValue?: T): T | undefined;
+
+export declare namespace find {
+    var fp: boolean;
+}
+
+/**
+ * Finds the first element in an array that satisfies a predicate function. If no such element is found, returns -1.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * findIndex(arr, isEven); // 1
+ * findIndex(arr, (num) => num > 5); // -1
+ * ```
+ *
+ * @param array - The array to search.
+ * @param predicate - A function that is called for each element in the array.
+ *
+ * @return The index of the first element that satisfies the predicate, or -1 if no such element is found.
+ */
+export declare function findIndex<T>(array: T[], predicate: Predicate<T>): number;
+
+export declare namespace findIndex {
+    var fp: boolean;
+}
+
+/**
+ * Finds the last element in the array that satisfies the provided predicate function.
+ * If no such element is found, returns the specified default value (if provided).
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * findLast(arr, isEven); // 4
+ * findLast(arr, (num) => num > 5, 0); // 0
+ * findLast(arr, (num) => num > 5); // undefined
+ * ```
+ *
+ * @param array - The array to search through.
+ * @param predicate - A function to test each element of the array.
+ * @param [defaultValue] - The value to return if no element satisfies the predicate.
+ *
+ * @return The last element in the array that satisfies the predicate, or the default value if none match.
+ */
+export declare function findLast<T>(array: T[], predicate: Predicate<T>, defaultValue?: T): T | undefined;
+
+export declare namespace findLast {
+    var fp: boolean;
+}
+
+declare type FirstParameters<T> = T extends [infer First extends FnDynamic, ...any] ? Parameters<First> : never;
+
+declare type FirstReturnType<F> = F extends [infer First extends FnDynamic, ...any] ? ReturnType<First> : never;
+
+declare type FlatArray_2<T> = T extends readonly (infer U)[] ? U : T;
+
+/**
+ * Flattens a nested array into a single-level array.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, [2, [3, [4, [5]]]]];
+ * flatten(arr) // [1, 2, 3, 4, 5];
+ * ```
+ *
+ * @param array - The array to flatten.
+ *
+ * @returns A single-level array.
+ */
+export declare function flatten<T>(array: T[]): FlatArray_2<T>[];
+
+export declare type Fn<P = any, R = any> = (...args: P[]) => R;
+
+export declare type FnAsync<P = any, R = any> = (...args: P[]) => Promise<R>;
+
+export declare type FnDynamic<P = any, R = any> = (...args: P[]) => R | Promise<R>;
+
+/**
+ * Creates a function that can be used in functional programming mode.
+ * This function is a wrapper around the original function, allowing you to pass the first argument as an array.
+ *
+ * @example
+ * ```ts
+ * import { fp } from './fp';
+ * import { map } from './map';
+ *
+ * const double = (num: number) => num * 2;
+ * const doubleArray = fp(map, double);
+ *
+ * doubleArray([1, 2, 3]) // [2, 4, 6]
+ * ```
+ *
+ * @param callback - The function to be wrapped.
+ * @param args - The arguments to be passed to the function.
+ *
+ * @returns A function that takes an array and applies the original function to it.
+ *
+ * @throws {TypeError} If the function cannot be used in functional programming mode.
+ */
+export declare const fp: <T, F extends Fn = Fn>(callback: F, ...args: RemoveFirstParameter<F>) => (array: T[]) => any;
+
+/**
+ * Checks if the first argument is greater than or equal to the second argument.
+ *
+ * @example
+ * ```ts
+ * gte(5, 3); // true
+ * gte(3, 5); // false
+ * gte(5, 5); // true
+ * gte(5, '3'); // false
+ * gte('5', 3); // false
+ * gte('5', '3'); // false
+ * ```
+ * @param a - The first argument to compare.
+ * @param b - The second argument to compare.
+ *
+ * @returns `true` if `a` is greater than or equal to `b`, otherwise `false`.
+ */
+export declare function ge(a: unknown, b: unknown): boolean;
+
+/**
+ * Groups the elements of an array based on the given key.
+ *
+ * @example
+ * ```ts
+ * const data = [{ a: 2 }, { a: 1 }];
+ * group(data, 'a') // { '1': [{ a: 2 }], '2': [{ a: 1 }] };
+ * ```
+ *
+ * @param array - The array to group.
+ * @param selector - The function to generate the key for each element. It can be a string representing the key or a function that returns the key.
+ *
+ * @returns an object with keys as the grouped values and values as arrays of elements.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function group<T, K extends keyof T, R extends T[K] extends string ? T[K] : never>(array: T[], selector: Selector<T>): Record<R, T[]>;
+
+export declare namespace group {
+    var fp: boolean;
+}
+
+/**
+ * Checks if the first argument is greater than the second argument.
+ *
+ * @example
+ * ```ts
+ * gt(5, 3); // true
+ * gt(3, 5); // false
+ * gt(5, 5); // false
+ * ```
+ *
+ * @param a - The first argument to compare.
+ * @param b - The second argument to compare.
+ *
+ * @returns `true` if `a` is greater than `b`, otherwise `false`.
+ */
+export declare function gt(a: unknown, b: unknown): boolean;
+
+/**
+ * Generates an array of dates between a start and end date, with a specified interval and step size.
+ *
+ * @example
+ * ```ts
+ * const options = { interval: 'D', steps: 1, latest: false };
+ *
+ * interval('2022-01-01', '2022-01-31', options); // Returns an array of dates for every day in January 2022
+ * ```
+ *
+ * @param start - The start date (Date object or ISO string).
+ * @param end - The end date (Date object or ISO string).
+ * @param options - Options for an interval and steps.
+ *
+ * @returns An array of generated dates.
+ */
+export declare function interval(start: Date | string, end: Date | string, { interval, steps, latest }?: IntervalOptions): Date[];
+
+declare type IntervalOptions = {
+    interval?: IntervalType;
+    steps?: number;
+    latest?: boolean;
+};
+
+declare type IntervalType = 'D' | 'W' | 'M' | 'MS' | 'ME' | 'Y' | 'YS' | 'YE';
+
+/**
+ * @description
+ * Checks if the value type of argument.
+ *
+ * @example
+ * ```ts
+ * is('array', []);
+ * is('boolean', true);
+ * is('date', new Date());
+ * is('defined', 123);
+ * is('empty', []);
+ * is('even', 2);
+ * is('function', () => {});
+ * is('match', { a: 1, b: 2 }, { a: 1 });
+ * is('nan', Number.NaN);
+ * is('negative', -123);
+ * is('nil', null);
+ * is('null', null);
+ * is('number', 123);
+ * is('object', {});
+ * is('odd', 3);
+ * is('positive', 123);
+ * is('string', 'hello');
+ * is('symbol', Symbol('test'));
+ * is('regex', /abc/);
+ * is('string', 'hello world');
+ * is('undefined', undefined);
+ * is('within', 1, 2, 3);
+ * is('zero', 0);
+ * is('eq', [1, 2, 3], [1, 2, 3]);
+ * is('ne', [1, 2, 3], [1, 2]);
+ * is('ge', 5, 5);
+ * is('gt', 5, 3);
+ * is('le', 5, 5);
+ * is('lt', 3, 5);
+ * ```
+ *
+ * @param type - The type to check against.
+ * @param args - The argument to be checked.
+ *
+ * @returns `true` if the value is of the specified type, else `false`.
+ */
+export declare function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;
+
+export declare function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;
+
+export declare function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;
+
+export declare function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;
+
+export declare function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;
+
+export declare function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;
+
+export declare function is(type: 'le', ...args: Parameters<typeof le>): boolean;
+
+export declare function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;
+
+export declare function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;
+
+export declare function is(type: 'array', arg: unknown): arg is Array<unknown>;
+
+export declare function is(type: 'string', arg: unknown): arg is string;
+
+export declare function is(type: 'number', arg: unknown): arg is number;
+
+export declare function is(type: 'object', arg: unknown): arg is object;
+
+export declare function is(type: 'nil', arg: unknown): arg is null | undefined;
+
+export declare function is(type: 'primitive', arg: unknown): arg is string | number | boolean;
+
+export declare function is(type: isType, arg: unknown): boolean;
+
+export declare const IS_ARRAY_ERROR_MSG = "Expected an array";
+
+export declare const IS_DATE_ERROR_MSG = "Expected a Date object";
+
+export declare const IS_EMPTY_ERROR_MSG = "Expected an empty value";
+
+export declare const IS_EQUAL_ERROR_MSG = "Expected two values to be equal";
+
+export declare const IS_FUNCTION_ERROR_MSG = "Expected a function";
+
+export declare const IS_NIL_ERROR_MSG = "Expected a null or undefined value";
+
+export declare const IS_NUMBER_ERROR_MSG = "Expected a number";
+
+export declare const IS_OBJECT_ERROR_MSG = "Expected an object";
+
+export declare const IS_PRIMITIVE_ERROR_MSG = "Expected a primitive value";
+
+export declare const IS_PROMISE_ERROR_MSG = "Expected a promise";
+
+export declare const IS_STRING_ERROR_MSG = "Expected a string";
+
+export declare const IS_WITHIN_ERROR_MSG = "Expected a number within a specified range";
+
+/**
+ * Determines if the passed value is an array.
+ *
+ * @example
+ * ```ts
+ * isArray([1, 2, 3]) // true
+ * isArray(1, 2, 3) // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is an array, else `false`.
+ */
+export declare function isArray(arg: unknown): arg is Array<unknown>;
+
+/**
+ * Checks if the value is a boolean.
+ *
+ * @example
+ * ```ts
+ * isBoolean(true); // true
+ * isBoolean(false); // true
+ * isBoolean(123); // false
+ * isBoolean('hello world'); // false
+ * isBoolean({}); // false
+ * isBoolean([]); // false
+ * isBoolean(new Date()); // false
+ * isBoolean(null); // false
+ * isBoolean(undefined); // false
+ * isBoolean(NaN); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a boolean, else `false`.
+ */
+export declare function isBoolean(arg: unknown): arg is boolean;
+
+/**
+ * Determines if the passed value is a valid Date Object.
+ *
+ * @example
+ * ```ts
+ * isDate(new Date()); // true
+ * isDate(123); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a valid Date object, else `false`.
+ */
+export declare function isDate(arg: unknown): arg is Date;
+
+/**
+ * Checks if a value is defined (not `undefined`).
+ *
+ * @example
+ * ```ts
+ * isDefined(123); // true
+ * isDefined(undefined); // false
+ * isDefined('hello world'); // true
+ * isDefined({}); // true
+ * isDefined([]); // true
+ * isDefined(null); // true
+ * ```
+ *
+ * @param arg - The value to check.
+ *
+ * @returns `true` if the value is defined, else `false`.
+ */
+export declare function isDefined<T>(arg: T | undefined): arg is T;
+
+/**
+ * Checks if the given argument is empty.
+ *
+ * @example
+ * ```ts
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(''); // true
+ * isEmpty(0); // false
+ * isEmpty(123); // false
+ * isEmpty('abc'); // false
+ * isEmpty([1, 2, 3]); // false
+ * isEmpty({ a: 1, b: 2 }); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if all arguments are `null`, `undefined`, `{}`, `[]`, or empty strings. Otherwise, it returns `false`.
+ */
+export declare function isEmpty(arg: any): boolean;
+
+/**
+ * Deeply compares two values for equality, including objects, arrays, and primitives.
+ * Detects circular references and optimizes performance.
+ *
+ * @example
+ * ```ts
+ * isEqual([1, 2, 3], [1, 2, 3]); // true
+ * isEqual([1, 2], [1, 2, 3]); // false
+ * isEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // true
+ * isEqual({ a: { b: 2 } }, { a: { b: 2 } }); // true
+ * isEqual({ a: 1 }, { a: 2 }); // false
+ * isEqual({ a: 1 }, { b: 1 }); // false
+ * isEqual(new Date('2023-01-01'), new Date('2023-01-01')); // true
+ * isEqual(new Date('2023-01-01'), new Date('2023-01-02')); // false
+ * isEqual(new Date('2023-01-01'), 1); // false
+ * ```
+ *
+ * @param a - First value to compare.
+ * @param b - Second value to compare.
+ * @returns Whether the values are deeply equal.
+ */
+export declare function isEqual(a: unknown, b: unknown): boolean;
+
+/**
+ * Checks if a number is even.
+ *
+ * @param {number} arg - The number to check.
+ *
+ * @returns {boolean} - Returns true if the number is even, otherwise false.
+ */
+export declare function isEven(arg: unknown): arg is number;
+
+/**
+ * Determines if the passed value is a function.
+ *
+ * @example
+ * ```ts
+ * isFunction(function() {}) // true
+ * isFunction(() => {}) // true
+ * isFunction('hello world') // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a function, else `false`.
+ */
+export declare function isFunction(arg: unknown): arg is (...args: any[]) => any;
+
+/**
+ * Performs a partial deep comparison between object and source to determine if object contains equivalent property values.
+ *
+ * @example
+ * ```ts
+ * const object = { a: 1, b: 2, c: { d: 3 } };
+ *
+ * isMatch(object, { a: 1, c: { d: 3 } }); // true
+ * isMatch(object, { a: 1, b: 2 }); // true
+ * isMatch(object, { a: 1, c: { d: 4 } }); // false
+ *
+ * isMatch([1, 2, 3], [1, 2]); // true
+ * isMatch([1, 2, 3], [1, 2, 3]); // true
+ * isMatch([1, 2, 3], [1, 2, 4]); // false
+ * ```
+ *
+ * @param object - The object to inspect.
+ * @param source - The object of property values to match.
+ *
+ * @returns `true` if the object is a match, else `false`.
+ */
+declare function isMatch(object: any, source: any): boolean;
+
+/**
+ * @description
+ * Checks if the value is a negative number.
+ *
+ * @example
+ * ```ts
+ * isNegative(-123); // true
+ * isNegative(123); // false
+ * isNegative(0); // false
+ * isNegative(0.1); // false
+ * isNegative(-0.1); // true
+ * isNegative('hello world'); // false
+ * isNegative({}); // false
+ * isNegative([]); // false
+ * isNegative(new Date()); // false
+ * isNegative(null); // false
+ * isNegative(undefined); // false
+ * isNegative(NaN); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a negative number, else `false`.
+ */
+export declare function isNegative(arg: unknown): arg is number;
+
+/**
+ * Determines if the passed value is null or undefined.
+ *
+ * @example
+ * ```ts
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(''); // false
+ * isNil(0); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is null or undefined, else `false`.
+ */
+export declare function isNil(arg: unknown): arg is null | undefined;
+
+/**
+ * Determines if the passed value is a number.
+ *
+ * @example
+ * ```ts
+ * isNumber(123); // true
+ * isNumber('hello world'); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a number, else `false`.
+ */
+export declare function isNumber(arg: unknown): arg is number;
+
+/**
+ * Determines if the passed value is an object.
+ *
+ * @example
+ * ```ts
+ * const value = { key: 'value' };
+ * isObject(value); // true
+ * isObject('hello world'); // false
+ * isObject(value, 1); // false
+ * isObject(value, value); // true
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is an object, else `false`.
+ */
+export declare function isObject(arg: unknown): arg is object;
+
+/**
+ * Checks if a number is odd.
+ *
+ * @param {number} arg - The number to check.
+ *
+ * @returns {boolean} - Returns true if the number is odd, otherwise false.
+ */
+export declare function isOdd(arg: unknown): arg is number;
+
+/**
+ * Checks if the value is a positive number.
+ *
+ * @example
+ * ```ts
+ * isPositive(123); // true
+ * isPositive(-123); // false
+ * isPositive(0); // false
+ * isPositive(0.1); // true
+ * isPositive(-0.1); // false
+ * isPositive('hello world'); // false
+ * isPositive({}); // false
+ * isPositive([]); // false
+ * isPositive(new Date()); // false
+ * isPositive(null); // false
+ * isPositive(undefined); // false
+ * isPositive(NaN); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a positive number, else `false`.
+ *
+ */
+export declare function isPositive(arg: unknown): arg is number;
+
+/**
+ * Type guard to check if a value is a primitive
+ *
+ * @example
+ * ```ts
+ * isPrimitive('Hello World'); // true
+ * isPrimitive(42); // true
+ * isPrimitive(true); // true
+ * isPrimitive({}); // false
+ * isPrimitive([]); // false
+ * isPrimitive(() => {}); // false
+ * ```
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a primitive, else `false`.
+ */
+export declare function isPrimitive(arg: unknown): arg is string | number | boolean;
+
+/**
+ * Determines if the passed value is a promise.
+ *
+ * @example
+ * ```ts
+ * isPromise(new Promise((resolve, reject) => {})); // true
+ * isPromise(async () => {}); // true
+ * isPromise(() => {}); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a promise, else `false`.
+ */
+export declare function isPromise(arg: unknown): arg is Promise<unknown>;
+
+/**
+ * Checks if the provided argument is a regular expression.
+ *
+ * @example
+ * ```ts
+ * isRegex(/abc/); // true
+ * isRegex(new RegExp('abc')); // true
+ * isRegex('abc'); // false
+ * isRegex(123); // false
+ * isRegex({}); // false
+ * isRegex([]); // false
+ * isRegex(null); // false
+ * isRegex(undefined); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @return `true` if the argument is a regular expression, otherwise `false`.
+ */
+export declare function isRegex(arg: unknown): arg is RegExp;
+
+/**
+ * Determines if the passed value is a String.
+ *
+ * @example
+ * ```ts
+ * isString('Hello World'); // true
+ * isString(42); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a String, else `false`.
+ */
+export declare function isString(arg: unknown): arg is string;
+
+declare type isType = ArgType | 'defined' | 'empty' | 'eq' | 'even' | 'ge' | 'gt' | 'le' | 'lt' | 'match' | 'ne' | 'negative' | 'nil' | 'odd' | 'positive' | 'regex' | 'within' | 'zero';
+
+/**
+ * Checks if a value is within a specified range.
+ *
+ * @example
+ * ```ts
+ * isWithin(1, 0, 1); // true
+ * isWithin(1, 0, 1, false); // false
+ * isWithin(0.5, 0, 1); // true
+ * ```
+ *
+ * @param arg - The value to be checked.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param inclusive - Whether the range is inclusive or exclusive. (defaults: `true`).
+ *
+ * @returns `true` if the value is in between, else `false`.
+ */
+export declare function isWithin(arg: unknown, min: unknown, max: unknown, inclusive?: boolean): boolean;
+
+/**
+ * Checks if the value is a positive number.
+ *
+ * @example
+ * ```ts
+ * isPositive(0); // true
+ * isPositive(123); // false
+ * isPositive(-123); // false
+ * isPositive(0.0000001); // false
+ * isPositive('hello world'); // false
+ * isPositive({}); // false
+ * isPositive([]); // false
+ * isPositive(new Date()); // false
+ * isPositive(null); // false
+ * isPositive(undefined); // false
+ * isPositive(NaN); // false
+ * ```
+ *
+ * @param arg - The argument to be checked.
+ *
+ * @returns `true` if the value is a positive number, else `false`.
+ *
+ */
+export declare function isZero(arg: unknown): arg is number;
+
+declare type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+
+/**
+ * Converts a string to kebab case.
+ *
+ * @example
+ * ```ts
+ * const text = 'Hello World';
+ * kebabCase(text); // 'hello-world'
+ * ```
+ *
+ * @param str - The string to convert.
+ *
+ * @returns The converted string.
+ */
+export declare function kebabCase(str: string): string;
+
+/**
+ * Returns an array of the keys for an object's properties.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2, c: 3 };
+ *
+ * keys(obj); // ['a', 'b', 'c']
+ * ```
+ *
+ * @param item - The object to query.
+ *
+ * @returns true if the object has the property, false otherwise.
+ */
+export declare function keys<T extends Obj, K extends keyof T>(item: T): K[];
+
+declare type LastParameters<T> = T extends [...any, infer Last extends FnDynamic] ? Parameters<Last> : never;
+
+declare type LastReturnType<T> = T extends [...any, infer Last extends FnDynamic] ? ReturnType<Last> : never;
+
+/**
+ * Check if the first argument is less than or equal to the second argument.
+ *
+ * @example
+ * ```ts
+ * le(3, 5); // true
+ * le(5, 3); // false
+ * le(5, 5); // true
+ * ```
+ *
+ * @param a - The first argument to compare.
+ * @param b - The second argument to compare.
+ *
+ * @returns `true` if `a` is less than or equal to `b`, otherwise `false`.
+ */
+export declare function le(a: unknown, b: unknown): boolean;
+
+export declare function list<T>(initialData: T[], config?: Config<T>): {
+    readonly current: T[];
+    data: T[];
+    filter(predicate: (item: T) => boolean): T[];
+    limit: number;
+    readonly meta: {
+        end: number;
+        isEmpty: boolean;
+        isFirst: boolean;
+        isLast: boolean;
+        limit: number;
+        page: number;
+        pages: number;
+        start: number;
+        total: number;
+    };
+    next(): void;
+    page: number;
+    readonly pages: T[][];
+    prev(): void;
+    reset(): T[];
+    search: (str: string) => void;
+    sort(fn?: (a: T, b: T) => number): T[];
+    [Symbol.iterator](): Generator<T[], void, unknown>;
+};
+
+/**
+ * Checks if the first argument is less than the second argument.
+ *
+ * @example
+ * ```ts
+ * lt(3, 5); // true
+ * lt(5, 3); // false
+ * lt(5, 5); // false
+ * ```
+ *
+ * @param a - The first argument to compare.
+ * @param b - The second argument to compare.
+ *
+ * @returns `true` if `a` is less than `b`, otherwise `false`.
+ */
+export declare function lt(a: unknown, b: unknown): boolean;
+
+/**
+ * Transforms an array by applying a callback function to each of its elements.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3];
+ * map(arr, x => x * 2); // [2, 4, 6]
+ * map(arr, async x => x * 2); // Promise<[2, 4, 6]>
+ * ```
+ *
+ * @param array - The array to be transformed.
+ * @param callback - The function to invoke for each element in the array.
+ *
+ * @return The transformed array, either as a synchronous result or a Promise if lazy is set.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function map<T, R, C extends CallbackDynamic<T, R>>(array: T[], callback: C): ResultArray<C>;
+
+export declare namespace map {
+    var fp: boolean;
+}
+
+/**
+ * Finds the maximum item in an array.
+ *
+ * @description
+ * This function can be used to find the maximum number, string, or any other type of item in an array.
+ *
+ * @example
+ * ```ts
+ * max([1, 2, 3]); // 3
+ * max([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 3
+ * max(['apple', 'banana', 'cherry']); // 'cherry'
+ * max([new Date('2023-01-01'), new Date('2022-01-01')]); // 2023-01-01
+ * ```
+ *
+ * @param array - The array to be searched.
+ * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.
+ *
+ * @return The item with the maximum value as determined by the callback function.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function max<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined;
+
+/**
+ * Returns the median of an array of numbers.
+ *
+ * @example
+ * ```ts
+ * median([1, 2, 3, 4, 100]); // 3
+ * median([1, 2, 3, 4, 5], (n) => n * 2); // 6
+ * median([]); // undefined
+ * median([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); // 5.5
+ * median([new Date(2020-01-01), new Date(2020-01-02), new Date(2020-01-31)]) // 2020-01-02
+ * ```
+ *
+ * @param arr - The array of numbers.
+ * @param callback - (optional) A callback function to map the numbers.
+ * @returns The median of the numbers.
+ */
+export declare function median<T>(arr: T[], callback?: (item: T) => number | Date): number | Date | undefined;
+
+/**
+ * Creates a function that memorizes the result of the provided function.
+ * Supports expiration (TTL) and limited cache size (LRU).
+ *
+ * @example
+ * ```ts
+ * const add = (x, y) => x + y;
+ * const memoizedAdd = memo(add, { ttl: 5000, maxSize: 10 });
+ *
+ * memoizedAdd(1, 2); // 3 (caches the result)
+ * memoizedAdd(1, 2); // 3 (from cache)
+ * ```
+ *
+ * @param fn - The function to memorize.
+ * @param options - Memoization options.
+ * @param [options.ttl] - (optional) time-to-live (TTL) for cache expiration (in milliseconds).
+ * @param [options.maxSize] - (optional) maximum cache size (LRU eviction).
+ *
+ * @returns A new function that memorizes the input function.
+ */
+export declare function memo<T extends Fn>(fn: T, { ttl, maxSize }?: MemoizeOptions): (...args: Parameters<T>) => ReturnType<T>;
+
+declare type MemoizeOptions = {
+    ttl?: number;
+    maxSize?: number;
+};
+
+declare type Merge<T extends Obj[]> = T extends [infer First, ...infer Rest] ? First extends Obj ? Rest extends Obj[] ? DeepMerge<First, Merge<Rest>> : First : Obj : Obj;
+
+/**
+ * Merges multiple objects based on a specified merge strategy.
+ *
+ * @example
+ * ```ts
+ * const obj1 = { a: 1, b: { x: 10, y: "hello" }, c: [1] };
+ * const obj2 = { b: { y: 20, z: true }, c: [2] };
+ * const obj3 = { d: false, c: [3] };
+ *
+ * merge("deep", obj1, obj2, obj3); // { a: 1, b: { x: 10, y: 20, z: true }, c: [1, 2, 3], d: false }
+ * merge("shallow", obj1, obj2, obj3); // { a: 1, b: { y: 20, z: true }, c: [3], d: false }
+ * ```
+ *
+ * @param [strategy='deep'] - The merging strategy to use.
+ * @param items - The objects to merge.
+ * @returns A new merged object.
+ */
+export declare function merge<T extends Obj[]>(strategy?: MergeStrategy, ...items: [...T]): Merge<T>;
+
+declare type MergeStrategy = 'deep' | 'shallow' | 'lastWins' | 'arrayConcat' | 'arrayReplace' | ((target: any, source: any) => any);
+
+/**
+ * Finds the minimum item in an array.
+ *
+ * @description
+ * This function can be used to find the minimum number, string, or any other type of item in an array.
+ *
+ * @example
+ * ```ts
+ * min([1, 2, 3]); // 1
+ * min([{ value: 1 }, { value: 2 }, { value: 3 }], item => item.value); // 1
+ * min(['apple', 'banana', 'cherry']); // 'apple'
+ * min([new Date('2023-01-01'), new Date('2022-01-01')]); // 2022-01-01
+ * ```
+ *
+ * @param array - The array to be searched.
+ * @param [callback] - (optional) The function to invoke for each element in the array to determine its value.
+ *
+ * @return The item with the minimum value as determined by the callback function.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined;
+
+export declare type Obj = Record<string, any>;
+
+/**
+ * Create a function that runs once and returns the first result.
+ *
+ * @example
+ * ```ts
+ * const onceRandom = once(() => Math.random())
+ * onceRandom() // 0.3
+ * onceRandom() // 0.3
+ *
+ * onceRandom.reset()
+ *
+ * onceRandom() // 0.2
+ * onceRandom() // 0.2
+ * ```
+ *
+ * @param fn - The function to wrap.
+ *
+ * @returns A function that can only be called once.
+ */
+export declare const once: <T extends Fn>(fn: T) => T & {
+    reset: () => void;
+};
+
+/**
+ * Parses a JSON string and returns the resulting object.
+ *
+ * @example
+ * ```ts
+ * const json = '{"a":1,"b":2,"c":3}';
+ * const result = parseJSON<Record<string, number>>(json, {
+ *   defaultValue: { a: 0, b: 0, c: 0 },
+ *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),
+ *   errorHandler: (err) => console.warn('Parsing failed:', err.message),
+ *   silent: true
+ * });
+ * console.log(result); // { a: 1, b: 2, c: 3 }
+ * ```
+ *
+ * @template T - The expected type of the parsed JSON.
+ * @param json - The JSON string to parse. If not a string, it is returned as is.
+ * @param options - Configuration options for parsing.
+ *
+ * @returns The parsed object if successful, otherwise the default value.
+ */
+export declare function parseJSON<T extends JSONValue>(json: unknown, options?: ParseJSONOptions<T>): T | undefined;
+
+declare interface ParseJSONOptions<T> {
+    defaultValue?: T;
+    reviver?: (key: string, value: any) => any;
+    validator?: (value: any) => boolean;
+    silent?: boolean;
+}
+
+/**
+ * Converts a string to Pascal case.
+ *
+ * @example
+ * ```ts
+ * const text = 'Hello World';
+ * pascalCase(text) // 'HelloWorld';
+ * ```
+ *
+ * @param str - The string to convert.
+ *
+ * @returns The converted string.
+ */
+export declare function pascalCase(str: string): string;
+
+/**
+ * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };
+ *
+ * getValue(obj, 'a.b.c'); // 3
+ * getValue(obj, 'a.b.d', 'default'); // 'default'
+ * getValue(obj, 'd[1]', undefined, { allowArrayIndex: true }); // 2
+ * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error
+ * ```
+ *
+ * @template T - The type of the object to query.
+ * @template P - The type of the path string.
+ * @param item - The object to query.
+ * @param path - The path of the property to get.
+ * @param [defaultValue] - The value returned for undefined resolved values.
+ * @param [options] - Additional options for value retrieval.
+ *
+ * @returns The resolved value.
+ *
+ * @throws If throwOnMissing is true and the path doesn't exist.
+ */
+export declare function path<T extends Obj, P extends string>(item: T, path: P, defaultValue?: unknown, options?: PathOptions): PathValue<T, P> | undefined;
+
+declare type PathOptions = {
+    throwOnMissing?: boolean;
+    allowArrayIndex?: boolean;
+};
+
+declare type PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? PathValue<T[Key], Rest> : undefined : P extends keyof T ? T[P] : undefined;
+
+/**
+ * Picks the first element from an array that satisfies a predicate function
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4];
+ * pick(arr, x => x * x, x => x > 2) // 9
+ * await pick(arr, async x => x * x, x => x > 2) // 9
+ * ```
+ *
+ * @param array - The array to search.
+ * @param callback - A function that is called for each element in the array.
+ * @param predicate - A function that is called to validate each element in the array.
+ *
+ * @return The first element that satisfies the predicate, or undefined if no such element is found.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function pick<T, R, C extends CallbackDynamic<T, R>>(array: T[], callback: C, predicate?: Predicate<T>): Result<C> | undefined;
+
+export declare namespace pick {
+    var fp: boolean;
+}
+
+/**
+ * Pipes multiple functions into a single function. It starts from the leftmost function and proceeds to the right.
+ *
+ * @example
+ * ```ts
+ * const add = (x) => x + 2;
+ * const multiply = (x) => x * 3;
+ * const subtract = (x) => x - 4;
+ * const pipedFn = pipe(subtract, multiply, add);
+ *
+ * pipedFn(5); // ((5-4) * 3) + 2 = 5
+ * ```
+ *
+ * @example
+ * ```ts
+ * const square = async (x) => x * x;
+ * const add = async (x) => x + 2;
+ * const pipedFn = pipe(square, add);
+ *
+ * await pipedFn(4); // (4 * 4) + 2 = 18
+ * ```
+ *
+ * @param fns - List of functions to be piped.
+ *
+ * @returns A new function that is the pipe of the input functions.
+ */
+export declare function pipe<T extends FnDynamic[]>(...fns: T): PipeReturn<T>;
+
+declare type PipeReturn<T extends FnDynamic[]> = (...args: FirstParameters<T>) => LastReturnType<T> extends Promise<any> ? Promise<Awaited<LastReturnType<T>>> : LastReturnType<T>;
+
+export declare type Predicate<T> = (value: T, index: number, array: T[]) => boolean | boolean[];
+
+/**
+ * Creates a Promise that can be aborted using an AbortController.
+ *
+ * @example
+ * ```ts
+ * const slowFn = () => new Promise(resolve => setTimeout(() => resolve('slow'), 10000));
+ * const fastFn = () => new Promise(resolve => setTimeout(() => resolve('fast'), 5000));
+ *
+ * predict(slowFn); // rejects after 7 seconds
+ * predict(fastFn); // resolves with 'fast' after 5 seconds
+ * ```
+ *
+ * @param fn - The function to execute, which receives an AbortSignal.
+ * @param options - The options for the abortable function.
+ * @param [options.signal] - The AbortSignal to use for aborting the Promise.
+ * @param [options.timeout=7000] - The timeout in milliseconds after which the Promise will be aborted.
+ *
+ * @returns - A Promise that resolves with the result of the callback or rejects if aborted.
+ */
+export declare function predict<T>(fn: (signal: AbortSignal) => Promise<T>, options?: {
+    signal?: AbortSignal;
+    timeout?: number;
+}): Promise<T>;
+
+export declare type Primitive = string | number | boolean;
+
+/**
+ * Creates a new Proxy for the given object that invokes functions when properties are accessed or modified.
+
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2 };
+ * const log = (prop, curr, prev, target) => console.log(`Property '${prop}' changed from ${prev} to ${curr}`);
+ * const proxyObj = proxy(obj, { set: log });
+ * proxyObj.a = 3; // logs 'Property 'a' changed from 1 to 3'
+ * ```
+ *
+ * @param item - The object to observe.
+ * @param options - Configuration options for the proxy.
+ * @param [options.set] - A function to call when a property is set. It receives the property name, current value, previous value, and the target object.
+ * @param [options.get] - A function to call when a property is accessed. It receives the property name, value, and the target object.
+ * @param [options.deep] - If true, the proxy will also apply to nested objects.
+ * @param [options.watch] - An array of property names to watch. If provided, only these properties will trigger the set and get functions.
+ *
+ * @returns A new Proxy for the given object.
+ */
+export declare function proxy<T extends Obj>(item: T, options: ProxyOptions<T>): T;
+
+declare type ProxyOptions<T> = {
+    set?: <K extends PropertyKey>(prop: K, curr: unknown, prev: unknown, target: T) => unknown;
+    get?: <K extends PropertyKey>(prop: K, val: unknown, target: T) => unknown;
+    deep?: boolean;
+    watch?: (keyof T)[];
+};
+
+/**
+ * Generates a random integer between two values, inclusive.
+ *
+ * @example
+ * ```ts
+ * random(1, 10); // a random integer between 1 and 10
+ * ```
+ *
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @returns A random integer between min and max.
+ */
+export declare function random(min: number, max: number): number;
+
+/**
+ * Creates an array of numbers progressing from start up to, but not including, end. A step is used to specify the difference between each number in the array.
+ *
+ * @example
+ * ```ts
+ * const start = 0;
+ * const stop = 10;
+ * const step = 2;
+ *
+ * range(start, stop, step) // [0, 2, 4, 6, 8];
+ * ```
+ *
+ * @param start - The start of the range.
+ * @param stop - The end of the range.
+ * @param step - The value to increment or decrement by.
+ *
+ * @returns The range of numbers.
+ */
+export declare function range(start: number, stop: number, step: number): number[];
+
+/**
+ * Creates an array of numbers progressing from min to max with a specified number of steps.
+ *
+ * @example
+ * ```ts
+ * const min = 0;
+ * const max = 10;
+ * const steps = 5;
+ *
+ * rate(min, max, steps) // [0, 2.5, 5, 7.5, 10];
+ * ```
+ *
+ * @param min - The start of the range.
+ * @param max - The end of the range.
+ * @param [steps=5] - The number of steps between min and max.
+ *
+ * @returns The range of numbers.
+ */
+export declare function rate(min: number, max: number, steps?: number): number[];
+
+/**
+ * Reduces an array to a single value by applying a callback function
+ * to each element in the array, passing the accumulated result and
+ * the current element as arguments. Supports both synchronous and
+ * asynchronous callback functions.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3];
+ * reduce(arr, (acc, curr) => acc + curr, 0); // 10
+ * await reduce(arr, async (acc, curr) => acc + curr, 0); // 10
+ * ```
+ *
+ * @param array - The array to reduce.
+ * @param callback - The callback function to apply to each element.
+ * @param initialValue - The initial value for the accumulator.
+ *
+ * @returns The reduced value, or a Promise that resolves to the reduced value if the callback is asynchronous.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function reduce<T, R, C extends Callback_2<R, T>>(array: T[], callback: C, initialValue: R): Result<C>;
+
+export declare namespace reduce {
+    var fn: boolean;
+}
+
+declare type RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;
+
+export declare type Result<C extends FnDynamic> = C extends FnAsync ? Promise<Awaited<ReturnType<C>>> : ReturnType<C>;
+
+export declare type ResultArray<C extends FnDynamic> = C extends FnAsync ? Promise<Awaited<ReturnType<C>>[]> : ReturnType<C>[];
+
+/**
+ * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.
+ *
+ * @example
+ * ```ts
+ * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })
+ *   .then(result => console.log(result))
+ *   .catch(error => console.error(error));
+ * ```
+ *
+ * @param fn - The asynchronous function to retry.
+ * @param options - (optional) Options for retrying the function.
+ * @param [options.times=3] - The number of retry attempts.
+ * @param [options.delay=250] - The delay in milliseconds between retries.
+ * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).
+ * @param [options.signal] - `AbortSignal` to allow canceling retries.
+ *
+ * @returns The result of the asynchronous function.
+ */
+export declare function retry<T>(fn: () => Promise<T>, { times, delay, backoff, signal, }?: {
+    times?: number;
+    delay?: number;
+    backoff?: number;
+    signal?: AbortSignal;
+}): Promise<T>;
+
+/**
+ * Rounds a number to a specified number of decimal places.
+ *
+ * The `precision` argument is limited to be within the range of -323 to +292 to avoid NaN results.
+ *
+ * @example
+ * ```ts
+ * round(123.456) // 123
+ * round(123.456, -1) // 120
+ * round(123.456, 1, Math.ceil) // 123.5
+ * round(123.456, 1, Math.floor) // 123.4
+ * ```
+ *
+ * @param value - The number to round.
+ * @param precision - The number of decimal places to round to.
+ * @param [parser] - (optional) function to convert the number to a value.
+ *
+ * @returns The rounded number.
+ */
+export declare function round(value: number, precision?: number, parser?: (value: number) => number): number;
+
+/**
+ * Performs a search on an array of objects, checking all values for a match with the search string.
+ *
+ * @example
+ * ```ts
+ * const data = [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }];
+ * search(data, 'doe', 0.5); // [{ name: 'John Doe', age: 25 }, { name: 'Jane Doe', age: 30 }]
+ * ```
+ *
+ * @param array - The array of objects to search.
+ * @param query - The string to search for.
+ * @param [tone=0.25] - Degree of similarity between 0 and 1.
+ *
+ * @returns The filtered array of objects that match the search string.
+ *
+ * @throws {Error} If input values are invalid.
+ */
+export declare function search<T>(array: T[], query: string, tone?: number): T[];
+
+/**
+ * Recursively checks if an object contains a value similar to the search string.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };
+ *
+ * seek(obj, 'hello'); // true
+ * seek(obj, 'world'); // true
+ * seek(obj, 'foo'); // false
+ * seek(obj, 'hello', 0.5); // true
+ * seek(obj, 'hello', 0.8); // true
+ * seek(obj, 'hello', 1); // true
+ * seek(obj, 'hello', 1.5); // false
+ * seek(obj, 'hello', -1); // false
+ * seek(obj, 'hello', 0); // false
+ * ```
+ *
+ * @param item - The object to search within.
+ * @param query - The search string.
+ * @param [tone=1] - The similarity threshold.
+ *
+ * @returns Whether the object contains a matching value.
+ */
+export declare function seek<T>(item: T, query: string, tone?: number): boolean;
+
+/**
+ * Selects elements from an array based on a callback function and an optional predicate function.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4];
+ * select(arr, x => x * x, x => x > 2) // [9, 16]
+ * await select(arr, async x => x * x, x => x > 2) // [9, 16]
+ * ```
+ *
+ * @param array - The array to select from.
+ * @param callback - The function to map the values.
+ * @param [predicate] - (optional) The function to filter the values.
+ *
+ * @returns A new array with the selected values.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function select<T, R, C extends CallbackDynamic<T, R>>(array: T[], callback: C, predicate?: Predicate<T>): ResultArray<C>;
+
+export declare namespace select {
+    var fp: boolean;
+}
+
+export declare type Selector<T> = keyof T | ((item: T) => Primitive);
+
+/**
+ * Shifts the elements of an array to the left by a specified number of positions.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4, 5];
+ * shift(arr, 2); // [3, 4, 5]
+ * shift(arr, 2, true); // [3, 4, 5, 1, 2]
+ * ```
+ * @param array - The array to shift.
+ * @param positions - The number of positions to shift the array.
+ * @param rotate - If `true`, the elements that are shifted out will be added to the end of the array.
+ *
+ * @returns A new array with the elements shifted.
+ *
+ * @throws {TypeError} If the first argument is not an array, or the second argument is not a number.
+ */
+export declare function shift<T>(array: T[], positions: number, rotate?: boolean): T[];
+
+export declare namespace shift {
+    var fp: boolean;
+}
+
+/**
+ * Shuffles an array randomly.
+ *
+ * @example
+ * ```ts
+ * const arr = [1, 2, 3, 4];
+ * shuffle(arr); // a shuffled version of the array
+ * ```
+ *
+ * @param array - The array to shuffle.
+ *
+ * @returns A new shuffled array.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function shuffle<T>(array: T[]): T[];
+
+/**
+ * Calculate the similarity between two strings using the Levenshtein distance algorithm.
+ *
+ * @example
+ * ```ts
+ * similarity('abc', 'abc') // 1
+ * similarity('a', 'b') // 0
+ * similarity('ab', 'ac') // 0.5
+ * similarity('doe', 'John Doe') // 0.25
+ * similarity('abc', 'axc') // 0.6666666666666667
+ * similarity('kitten', 'sitting') // 0.5714285714285714
+ * ```
+ *
+ * @param str1 - The first string.
+ * @param str2 - The second string.
+ *
+ * @returns A number between 0 and 1 representing the similarity between the two strings.
+ */
+export declare function similarity(str1: unknown, str2: unknown): number;
+
+/**
+ * Creates a Promise that resolves after a specified amount of time.
+ *
+ * @example
+ * ```ts
+ * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second
+ * ```
+ *
+ * @param timeout - The number of milliseconds to wait before resolving the Promise.
+ *
+ * @returns A Promise that resolves after the specified time.
+ */
+export declare function sleep(timeout: number): Promise<void>;
+
+/**
+ * Converts a string to snake case.
+ *
+ * @example
+ * ```ts
+ * const text = 'Hello World';
+ * toSnakeCase(text) // 'hello_world';
+ * ```
+ *
+ * @param str - The string to convert.
+ *
+ * @returns The converted string.
+ */
+export declare function snakeCase(str: string): string;
+
+/**
+ * Checks if at least one element in the array satisfies the provided predicate function.
+ *
+ * @example
+ * ```ts
+ * some([1, 2, 3], (n) => n === 2) // true
+ * some([1, 2, 3], (n) => n === 4) // false
+ * ```
+ *
+ * @param array - The array to be checked.
+ * @param predicate - The function to test each element of the array.
+ *
+ * @returns `true` if at least one element satisfies the predicate, otherwise `false`.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare function some<T>(array: T[], predicate: Predicate<T>): boolean;
+
+export declare namespace some {
+    var fp: boolean;
+}
+
+/**
+ * Sorts an array of objects by a specific key in ascending order.
+ *
+ * @example
+ * ```ts
+ * const data = [{ a: 2 }, { a: 3 }, { a: 1 }];
+ * sort(data, (item) => item.a); // [{ a: 1 }, { a: 2 }, { a: 3 }]
+ * ```
+ *
+ * @param array - The array of objects to sort.
+ * @param selector - A function that extracts the key to sort by.
+ * @param desc - A boolean indicating whether to sort in descending order (default: false).
+ *
+ * @returns A new array sorted by the specified key.
+ *
+ * @throws {TypeError} If the provided array is not an array.
+ */
+export declare const sort: {
+    <T>(array: T[], selector: (item: T) => any, desc?: boolean): T[];
+    fp: boolean;
+};
+
+/**
+ * Sorts an array of objects based on multiple selectors.
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { name: 'Alice', age: 30 },
+ *   { name: 'Bob', age: 25 },
+ *   { name: 'Charlie', age: 35 },
+ *   { name: 'Alice', age: 25 },
+ *   { name: 'Bob', age: 30 },
+ *   { name: 'Charlie', age: 30 },
+ * ].sortBy(data, { name: 'asc', age: 'desc' }); // [ { name: 'Alice', age: 30 }, { name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }, { name: 'Bob', age: 25 }, { name: 'Charlie', age: 35 }, { name: 'Charlie', age: 30 } ]
+ * ```
+ *
+ * @param array - The array to sort.
+ * @param selectors - An object where keys are the properties to sort by and values are 'asc' or 'desc'.
+ * @returns A new sorted array.
+ */
+export declare const sortBy: <T>(array: T[], selectors: Partial<Record<keyof T, "asc" | "desc">>) => T[];
+
+/**
+ * Replaces the first element in an array that satisfies the provided predicate function with a new value.
+ *
+ * @example
+ * ```ts
+ * substitute([1, 2, 3], (n) => n === 2, 4) // [1, 4, 3]
+ * ```
+ *
+ * @param array - The array to search.
+ * @param predicate - A function to test each element of the array.
+ * @param value - The new value to replace the found element.
+ *
+ * @return A new array with the replaced value.
+ *
+ * @throws {TypeError} If the first argument is not an array.
+ */
+export declare function substitute<T>(array: T[], predicate: Predicate<T>, value: T): T[];
+
+export declare namespace substitute {
+    var fn: boolean;
+}
+
+/**
+ * Sum numbers in an array or numbers mapped by a callback function.
+ *
+ * @example
+ * ```ts
+ * sum([1, 2, 3]) // 6
+ * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6
+ * sum(['apple', 'banana', 'cherry']) // TypeError
+ * sum([new Date('2023-01-01'), new Date('2022-01-01')]) // 467308800000
+ * ```
+ *
+ * @param array - The array to sum.
+ * @param callback - An optional callback function to map the values.
+ *
+ * @returns The sum of the numbers in the array or the sum of the mapped values.
+ */
+export declare function sum<T>(array: T[], callback?: (item: T) => number | Date): number | Date | undefined;
+
+declare type SyncCallback<R, T> = (prev: R, curr: T, index: number, array: T[]) => R;
+
+/**
+ * Creates a throttled function that only invokes the provided function at most once per every specified milliseconds.
+ *
+ * @example
+ * ```ts
+ * const log = () => console.log('Hello, world!');
+ * const throttledLog = throttle(log, 1000);
+ *
+ * throttledLog(); // logs 'Hello, world!' immediately
+ * throttledLog(); // does nothing because less than 1 second has passed since the last invocation
+ * setTimeout(throttledLog, 1000); // logs 'Hello, world!' after 1 second
+ * ```
+ *
+ * @param fn - The function to throttle.
+ * @param [delay=700] - The number of milliseconds to wait before invoking the function again.
+ *
+ * @returns A new function that throttles the input function.
+ */
+export declare function throttle<T extends Fn>(fn: T, delay?: number): (...args: Parameters<T>) => void;
+
+/**
+ * Calculates the remaining time until a target date.
+ *
+ * @example
+ * ```ts
+ * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 5)); // { value: 5, unit: 'DAY' }
+ * timeDiff(new Date(Date.now() - 1000 * 60 * 60 * 24 * 3), 'past'); // { value: 3, unit: 'DAY' }
+ * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 31)); // { value: 1, unit: 'MONTH' }
+ * timeDiff(new Date(Date.now() + 1000 * 60 * 60 * 24 * 365)); // { value: 1, unit: 'YEAR' }
+ * ```
+ *
+ * @param a - The target date (Date object or ISO string).
+ * @param b - The target date (Date object or ISO string).
+ * @param allowedUnits - (optional) array of units to filter the result. If provided, only these units will be considered.
+ *
+ * @returns An object containing the remaining time and its unit ('DAY', 'HOUR', or 'MINUTE').
+ */
+export declare function timeDiff(a: Date | string, b?: Date | string, allowedUnits?: TimeUnit[]): TimeResult;
+
+export declare namespace timeDiff {
+    var defaultUnits: (units: TimeUnit[]) => void;
+}
+
+export declare type TimeDirection = 'FUTURE' | 'PAST';
+
+export declare type TimeResult = {
+    unit: TimeUnit;
+    value: number;
+};
+
+export declare type TimeUnit = 'YEAR' | 'MONTH' | 'WEEK' | 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND' | 'INVALID_DATE';
+
+/**
+ * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign "…".
+ *
+ * @example
+ * ```ts
+ * const text = 'Hello World';
+ * truncate(text, 5); // 'Hello…'
+ * truncate(text, 3, true); // 'Hello…'
+ * truncate(text, 5, true, '...'); // 'Hello...'
+ * ```
+ *
+ * @param str - The string to truncate.
+ * @param limit - The maximum string length.
+ * @param completeWords - If true, the string is truncated to the nearest word, instead of character.
+ * @param ellipsis - The characters to end the truncated string with.
+ *
+ * @returns The truncated string.
+ */
+export declare function truncate(str: string, limit?: number, completeWords?: boolean, ellipsis?: string): string;
+
+/**
+ * Returns the type of the given argument.
+ *
+ * @example
+ * ```ts
+ * typeOf(null); // 'null'
+ * typeOf(undefined); // 'undefined'
+ * typeOf(NaN); // 'nan'
+ * typeOf(async function() {}); // 'promise'
+ * typeOf(123); // 'number'
+ * typeOf('abc'); // 'string'
+ * typeOf({}); // 'object'
+ * typeOf([]); // 'array'
+ * typeOf(() => {}); // 'function'
+ * typeOf(new Date()); // 'date'
+ * typeOf(new Error()); // 'error'
+ * typeOf(new Map()); // 'map'
+ * typeOf(new Set()); // 'set'
+ * typeOf(new WeakMap()); // 'weakmap'
+ * typeOf(new WeakSet()); // 'weakset'
+ * typeOf(new RegExp('')); // 'regexp'
+ * ```
+ *
+ * @param arg - The argument whose type is to be determined.
+ *
+ * @returns The type of the argument.
+ */
+export declare function typeOf(arg: unknown): ArgType;
+
+/**
+ * Creates a new array with duplicate values removed.
+ *
+ * @example
+ * ```ts
+ * uniq([1, 2, 2, 3, 3, 3]); // [1, 2, 3]
+ * const arrObj = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }, { id: 3 }, { id: 3 }];
+ * uniq(arrObj, 'id'); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * uniq(arrObj, item => item.id); // [{ id: 1 }, { id: 2 }, { id: 3 }]
+ * ```
+ *
+ * @param array - The array to process.
+ * @param [selector] - The key(s) to compare objects or a function to generate comparison values.
+
+ * @returns A new duplicate-free array.
+
+ * @throws {TypeError} - If the input is not an array or if the key is invalid.
+ */
+export declare function uniq<T>(array: T[], selector?: Selector<T>): T[];
+
+export declare namespace uniq {
+    var fp: boolean;
+}
+
+/**
+ * Generates a unique identifier.
+ *
+ * @example
+ * ```ts
+ * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'
+ * ```
+ *
+ * @returns A unique identifier.
+ */
+export declare function uuid(): string;
+
+/**
+ * Returns an array of values for an object's properties
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2, c: 3 };
+ * toValues(obj); // [1, 2, 3]
+ * ```
+ *
+ * @param item - The object whose property values are to be returned.
+ *
+ * @returns an array of the object's own enumerable string-keyed property values.
+ */
+export declare function values<T extends Obj, K extends keyof T>(item: T): T[K][];
+
+/**
+ * Creates a function that runs the provided callback in a web worker with specified dependencies.
+ *
+ * @example
+ * const sum = worker(({ _ }) => (...args) => _.sum([...args]), ['https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js']);
+ * await sum(1, 2); // 3
+ *
+ * @param callback - A function that receives the worker's `self` and performs work.
+ * @param dependencies - (optional) array of URLs to scripts that the worker should import.
+ *
+ * @returns A function that takes the arguments for the callback and returns a promise with the result.
+ */
+export declare function worker<T extends (...args: any) => any, R = Awaited<ReturnType<T>>>(callback: (self: any) => T, dependencies?: string[]): (...args: Parameters<T>) => Promise<R>;
+
+export { }