@vielzeug/toolkit 1.1.3 → 2.1.0

package/dist/index.d.ts

@@ -1,2813 +1,77 @@
-/**
- * Returns the absolute value of a number.
- * Supports both regular numbers and bigint.
- *
- * @example
- * ```ts
- * abs(-5); // 5
- * abs(3); // 3
- * abs(-100n); // 100n
- * ```
- *
- * @param value - The number or bigint to get absolute value of
- * @returns Absolute value
- */
-export declare function abs(value: number): number;
-
-export declare function abs(value: bigint): bigint;
-
-/**
- * Adds two numbers with precision handling for financial calculations.
- * Supports both regular numbers and bigint for exact precision.
- *
- * @example
- * ```ts
- * add(10, 20); // 30
- * add(0.1, 0.2); // 0.3 (precision-safe)
- * add(100n, 200n); // 300n
- * ```
- *
- * @param a - First number or bigint
- * @param b - Second number or bigint
- * @returns Sum of a and b
- */
-export declare function add(a: number, b: number): number;
-
-export declare function add(a: bigint, b: bigint): bigint;
-
-/**
- * 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;
-}
-
-/**
- * Distributes an amount proportionally according to given ratios.
- * Handles rounding to ensure the sum equals the original amount exactly.
- * Critical for financial operations like splitting payments to avoid rounding errors.
- *
- * @example
- * ```ts
- * // Split $100 in ratio 1:2:3
- * allocate(100, [1, 2, 3]);
- * // [17, 33, 50] - sum is exactly 100
- *
- * // Split with bigint (e.g., cents)
- * allocate(10000n, [1, 1, 1]);
- * // [3334n, 3333n, 3333n] - sum is exactly 10000n
- * ```
- *
- * @param amount - Total amount to allocate
- * @param ratios - Array of ratios for distribution
- * @returns Array of allocated amounts (sum equals original amount)
- * @throws {Error} If ratios array is empty or contains negative values
- */
-export declare function allocate(amount: number, ratios: number[]): number[];
-
-export declare function allocate(amount: bigint, ratios: number[]): bigint[];
-
-/**
- * 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';
-
-/**
- * Arranges (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 },
- * ].arrange(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 arrange: <T>(array: T[], selectors: Partial<Record<keyof T, "asc" | "desc">>) => T[];
-
-/**
- * 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;
-
-/**
- * Creates a generic key-value cache with automatic garbage collection and observer support.
- *
- * @example
- * ```ts
- * const myCache = cache<string>();
- * myCache.set(['user', 1], 'John Doe');
- * const value = myCache.get(['user', 1]); // 'John Doe'
- * myCache.scheduleGc(['user', 1], 5000); // Auto-delete after 5s
- * ```
- *
- * @template T - The type of values stored in the cache.
- *
- * @returns A cache instance with get, set, delete, clear, and GC methods.
- */
-export declare function cache<T>(): {
-    clear: () => void;
-    delete: (key: readonly unknown[]) => boolean;
-    get: (key: readonly unknown[]) => T | undefined;
-    getMeta: (key: readonly unknown[]) => Record<string, unknown> | undefined;
-    getMetaByHash: (keyHash: string) => Record<string, unknown> | undefined;
-    hash: (key: readonly unknown[]) => string;
-    listMetaHashes: () => string[];
-    scheduleGc: (key: readonly unknown[], delayMs: number) => void;
-    set: (key: readonly unknown[], value: T) => void;
-    setMeta: (key: readonly unknown[], meta: Record<string, unknown>) => void;
-    size: () => number;
-};
-
-/** 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.
- *
- * @throws {Error} If the item cannot be cloned.
- */
-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>;
-
-/**
- * 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;
-}
-
-/**
- * Formats a monetary amount as a currency string with proper locale and symbol.
- * Handles decimal places automatically based on currency.
- *
- * @example
- * ```ts
- * const money = { amount: 123456n, currency: 'USD' };
- *
- * currency(money); // '$1,234.56' (default en-US)
- * currency(money, { locale: 'de-DE' }); // '1.234,56 $'
- * currency(money, { style: 'code' }); // 'USD 1,234.56'
- * currency(money, { style: 'name' }); // '1,234.56 US dollars'
- * ```
- *
- * @param money - Money object to format
- * @param options - Formatting options
- * @returns Formatted currency string
- */
-export declare function currency(money: Money, options?: CurrencyFormatOptions): string;
-
-/**
- * Options for currency formatting.
- */
-export declare type CurrencyFormatOptions = {
-    locale?: string;
-    style?: 'symbol' | 'code' | 'name';
-    minimumFractionDigits?: number;
-    maximumFractionDigits?: number;
-};
-
-export declare type Curried<P extends readonly unknown[], R> = P extends readonly [] ? () => R : <A extends readonly [unknown, ...(readonly unknown[])]>(...args: A) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;
-
-export declare function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;
-
-export declare function curry<T extends (...args: any[]) => any, N extends number>(fn: T, arity: N): Curried<Take<N, Parameters<T>>, ReturnType<T>>;
-
-/**
- * Debounce a function (trailing). Use `flush` to invoke immediately,
- * `cancel` to clear, and `pending` to check if an invocation is scheduled.
- */
-export declare function debounce<T extends Fn>(fn: T, delay?: number): Debounced<T>;
-
-export declare type Debounced<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {
-    cancel(): void;
-    flush(): ReturnType<T> | undefined;
-    pending(): boolean;
-};
-
-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;
-
-/**
- * Creates a deferred promise with resolve and reject methods exposed.
- * Useful for creating promises that are resolved/rejected externally.
- *
- * @example
- * ```ts
- * const deferred = defer<string>();
- *
- * setTimeout(() => {
- *   deferred.resolve('Done!');
- * }, 1000);
- *
- * const result = await deferred.promise; // 'Done!'
- * ```
- *
- * @returns Object with promise and resolve/reject methods
- */
-export declare function defer<T = void>(): {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
-};
-
-/**
- * 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>;
-
-/**
- * Distributes an amount evenly among N parties.
- * Handles rounding to ensure the sum equals the original amount exactly.
- * Useful for splitting bills, costs, or payments equally.
- *
- * @example
- * ```ts
- * // Split $100 among 3 people
- * distribute(100, 3);
- * // [34, 33, 33] - sum is exactly 100
- *
- * // Split with bigint (e.g., cents)
- * distribute(10000n, 3);
- * // [3334n, 3333n, 3333n] - sum is exactly 10000n
- * ```
- *
- * @param amount - Total amount to distribute
- * @param parts - Number of parts to divide into
- * @returns Array of distributed amounts (a sum equals original amount)
- * @throws {Error} If parts are less than 1
- */
-export declare function distribute(amount: number, parts: number): number[];
-
-export declare function distribute(amount: bigint, parts: number): bigint[];
-
-/**
- * Divides a number by a divisor with precision handling for financial calculations.
- * Supports both regular numbers and bigint for exact precision.
- *
- * @example
- * ```ts
- * divide(20, 5); // 4
- * divide(0.6, 3); // 0.2 (precision-safe)
- * divide(500n, 5n); // 100n
- * ```
- *
- * @param a - Number to divide (dividend)
- * @param b - Divisor
- * @returns Quotient of a divided by b
- * @throws {Error} If divisor is zero
- */
-export declare function divide(a: number, b: number): number;
-
-export declare function divide(a: bigint, b: bigint): bigint;
-
-/**
- * “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;
-}
-
-/**
- * Converts money from one currency to another using the provided exchange rate.
- * Maintains precision by using bigint arithmetic.
- *
- * @example
- * ```ts
- * const usd = { amount: 100000n, currency: 'USD' }; // $1,000.00
- * const rate = { from: 'USD', to: 'EUR', rate: 0.85 };
- *
- * exchange(usd, rate);
- * // { amount: 85000n, currency: 'EUR' } // €850.00
- * ```
- *
- * @param money - Money to convert
- * @param rate - Exchange rate information
- * @returns Converted money in target currency
- * @throws {Error} If source currency doesn't match rate.from
- */
-export declare function exchange(money: Money, rate: ExchangeRate): Money;
-
-/**
- * Exchange rate for currency conversion.
- */
-export declare type ExchangeRate = {
-    from: string;
-    to: string;
-    rate: number;
-};
-
-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 string | number | symbol>(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 type List<T, F, S> = {
-    readonly current: readonly T[];
-    readonly meta: Meta;
-    subscribe(listener: () => void): () => void;
-    goTo(page: number): void;
-    next(): void;
-    prev(): void;
-    reset(): void;
-    search(query: string, opts?: {
-        immediate?: boolean;
-    }): void;
-    setData?(data: readonly T[]): void;
-    setFilter(filter: F): void;
-    setLimit(n: number): void;
-    setSort(sort?: S): void;
-    batch(mutator: (ctx: {
-        setLimit(n: number): void;
-        setFilter(f: F): void;
-        setSort(s?: S): void;
-        setQuery(q: string): void;
-        setData?(d: readonly T[]): void;
-        goTo(p: number): void;
-    }) => void): void;
-};
-
-export declare function list<T>(initialData: readonly T[], cfg?: LocalConfig<T>): List<T, Predicate<T>, Sorter<T>>;
-
-declare type LocalConfig<T> = Readonly<{
-    debounceMs?: number;
-    filterFn?: Predicate<T>;
-    limit?: number;
-    searchFn?: (items: readonly T[], query: string, tone: number) => readonly T[];
-    searchTone?: number;
-    sortFn?: Sorter<T>;
-}>;
-
-/**
- * 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).
- * @param [options.resolver] - (optional) custom function to resolve the cache key.
- *
- * @returns A new function that memorizes the input function.
- */
-export declare function memo<T extends Fn>(fn: T, { ttl, maxSize, resolver }?: MemoizeOptions<T>): (...args: Parameters<T>) => ReturnType<T>;
-
-declare type MemoizeOptions<T extends Fn> = {
-    ttl?: number;
-    maxSize?: number;
-    resolver?: (...args: Parameters<T>) => string;
-};
-
-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);
-
-export declare type Meta = Readonly<{
-    end: number;
-    isEmpty: boolean;
-    isFirst: boolean;
-    isLast: boolean;
-    limit: number;
-    page: number;
-    pages: number;
-    start: number;
-    total: number;
-}>;
-
-/**
- * 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;
-
-/**
- * Represents a monetary amount with currency.
- * Amount is stored as bigint (minor units/cents) for precision.
- */
-export declare type Money = {
-    readonly amount: bigint;
-    readonly currency: string;
-};
-
-/**
- * Multiplies a number by a scalar with precision handling for financial calculations.
- * Supports both regular numbers and bigint for exact precision.
- *
- * @example
- * ```ts
- * multiply(10, 5); // 50
- * multiply(0.1, 3); // 0.3 (precision-safe)
- * multiply(100n, 5n); // 500n
- * ```
- *
- * @param a - Number to multiply
- * @param b - Multiplier
- * @returns Product of a and b
- */
-export declare function multiply(a: number, b: number): number;
-
-export declare function multiply(a: bigint, b: bigint): bigint;
-
-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;
-};
-
-/**
- * Processes an array with an async callback with controlled parallelism.
- * Similar to Promise.all, but limits how many items are processed concurrently.
- * Returns an ordered array of results.
- *
- * @example
- * ```ts
- * // Process 3 items at a time
- * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {
- *   await delay(100);
- *   return n * 2;
- * });
- * // [2, 4, 6, 8, 10]
- *
- * // With abort signal
- * const controller = new AbortController();
- * const results = await parallel(2, items, async (item) => {
- *   return processItem(item);
- * }, controller.signal);
- * ```
- *
- * @param limit - Maximum number of concurrent operations (must be >= 1)
- * @param array - Array of items to process
- * @param callback - Async function to process each item
- * @param signal - Optional AbortSignal to cancel processing
- * @returns Promise resolving to an ordered array of results
- * @throws {Error} If limit is less than 1
- * @throws {DOMException} If aborted via signal
- */
-export declare function parallel<T, R>(limit: number, array: T[], callback: (item: T, index: number, array: T[]) => Promise<R>, signal?: AbortSignal): Promise<R[]>;
-
-/**
- * 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 type 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 = T>(array: T[], callback: (item: T, index: number, array: T[]) => R, predicate?: (item: T, index: number, array: T[]) => boolean): R | 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>;
-
-/**
- * Creates a promise pool that limits the number of concurrent promises.
- * Useful for rate limiting API calls or controlling resource usage.
- *
- * @example
- * ```ts
- * const requestPool = pool(3);
- *
- * const results = await Promise.all([
- *   requestPool(() => fetch('/api/1')),
- *   requestPool(() => fetch('/api/2')),
- *   requestPool(() => fetch('/api/3')),
- *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish
- * ]);
- * ```
- *
- * @param limit - Maximum number of concurrent promises
- * @returns Function that accepts a promise-returning function and executes it when a slot is available
- */
-export declare function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T>;
-
-export declare type Predicate<T> = (value: T, index: number, array: readonly T[]) => 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)[];
-};
-
-/**
- * Removes all nullable and empty values from strings, arrays, or objects.
- *
- * - For strings: Removes leading/trailing whitespace and returns undefined if empty
- * - For arrays: Recursively removes null, undefined, empty strings, and empty objects/arrays
- * - For objects: Recursively removes properties with null, undefined, empty strings, and empty objects/arrays
- *
- * @example
- * ```ts
- * prune('  hello  '); // 'hello'
- * prune('   '); // undefined
- * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]
- * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }
- * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }
- * ```
- *
- * @param value - The value to prune (can be string, array, object, or any other type)
- * @returns The pruned value, or undefined if the result would be empty
- */
-export declare function prune<T>(value: T): T | undefined;
-
-/**
- * Creates a promise queue that processes promises sequentially with optional concurrency limit.
- *
- * @example
- * ```ts
- * const requestQueue = queue({ concurrency: 2 });
- *
- * requestQueue.add(() => fetch('/api/1'));
- * requestQueue.add(() => fetch('/api/2'));
- * requestQueue.add(() => fetch('/api/3'));
- *
- * await requestQueue.onIdle(); // Wait for all tasks to complete
- * ```
- *
- * @param options - Queue configuration
- * @param options.concurrency - Maximum number of concurrent promises (default: 1)
- * @returns Queue instance with add, onIdle, and clear methods
- */
-export declare function queue(options?: {
-    concurrency?: number;
-}): {
-    /**
-     * Adds a promise-returning function to the queue
-     */
-    add: <T>(fn: () => Promise<T>) => Promise<T>;
-    /**
-     * Clears all pending tasks from the queue
-     */
-    clear: () => void;
-    /**
-     * Returns a promise that resolves when the queue becomes idle
-     */
-    onIdle: () => Promise<void>;
-    /**
-     * Returns the number of currently active promises
-     */
-    readonly pending: number;
-    /**
-     * Returns the current size of the queue
-     */
-    readonly size: number;
-};
-
-/**
- * Race multiple promises but with a guaranteed minimum delay.
- * Useful for showing loading states for at least a minimum duration.
- *
- * @example
- * ```ts
- * // Show loading spinner for at least 500ms
- * const result = await race(
- *   fetchData(),
- *   500
- * );
- *
- * // With multiple promises
- * const result = await race(
- *   [fetch('/api/1'), fetch('/api/2')],
- *   1000
- * );
- * ```
- *
- * @param promises - Single promise or array of promises to race
- * @param minDelay - Minimum delay in milliseconds before resolving
- * @returns Promise that resolves with the first result after the minimum delay
- */
-export declare function race<T>(promises: Promise<T> | Promise<T>[], minDelay: number): Promise<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.
- *
- * @throws {TypeError} If start, stop, or step are not finite numbers.
- * @throws {Error} If step is 0 or if range exceeds maximum size.
- */
-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 RemoteConfig<T, F, S> = Readonly<{
-    debounceMs?: number;
-    fetch: (q: RemoteQuery<F, S>) => Promise<RemoteResult<T>>;
-    initialFilter?: F;
-    initialSort?: S;
-    limit?: number;
-}>;
-
-export declare type RemoteList<T, F, S> = {
-    readonly current: readonly T[];
-    readonly meta: RemoteMeta;
-    subscribe(listener: () => void): () => void;
-    goTo(page: number): Promise<void>;
-    invalidate?(): void;
-    next(): Promise<void>;
-    prev(): Promise<void>;
-    refresh(): Promise<void>;
-    reset(): Promise<void>;
-    search(query: string, opts?: {
-        immediate?: boolean;
-    }): Promise<void>;
-    setFilter(filter: F): Promise<void>;
-    setLimit(n: number): Promise<void>;
-    setSort(sort?: S): Promise<void>;
-    batch(mutator: (ctx: {
-        setLimit(n: number): void;
-        setFilter(f: F): void;
-        setSort(s?: S): void;
-        setQuery(q: string): void;
-        setData?(d: readonly T[]): void;
-        goTo(p: number): void;
-    }) => void): Promise<void>;
-};
-
-export declare function remoteList<T, F = Record<string, unknown>, S = {
-    key?: string;
-    dir?: 'asc' | 'desc';
-}>(cfg: RemoteConfig<T, F, S>): RemoteList<T, F, S>;
-
-export declare type RemoteMeta = Readonly<{
-    end: number;
-    error: string | null;
-    isEmpty: boolean;
-    isFirst: boolean;
-    isLast: boolean;
-    limit: number;
-    loading: boolean;
-    page: number;
-    pages: number;
-    start: number;
-    total: number;
-}>;
-
-declare type RemoteQuery<F, S> = Readonly<{
-    filter?: F;
-    limit: number;
-    page: number;
-    search?: string;
-    sort?: S;
-}>;
-
-declare type RemoteResult<T> = Readonly<{
-    items: readonly T[];
-    total: number;
-}>;
-
-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 | ((attempt: number, delay: number) => 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.
- *
- * @throws {TypeError} If timeout is not a non-negative number.
- */
-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;
-};
-
-export declare type Sorter<T> = (a: T, b: T) => number;
-
-/**
- * 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;
-}
-
-/**
- * Subtracts one number from another with precision handling for financial calculations.
- * Supports both regular numbers and bigint for exact precision.
- *
- * @example
- * ```ts
- * subtract(20, 10); // 10
- * subtract(0.3, 0.1); // 0.2 (precision-safe)
- * subtract(300n, 100n); // 200n
- * ```
- *
- * @param a - Number to subtract from
- * @param b - Number to subtract
- * @returns Difference of a and b
- */
-export declare function subtract(a: number, b: number): number;
-
-export declare function subtract(a: bigint, b: bigint): bigint;
-
-/**
- * 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
- * ```
- *
- * @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): number | undefined;
-
-declare type SyncCallback<R, T> = (prev: R, curr: T, index: number, array: T[]) => R;
-
-/** biome-ignore-all lint/suspicious/noExplicitAny: - */
-/**
- * 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.
- * @param arity - The number of arguments the function expects. Defaults to the function's length.
- *
- * @returns A curried version of the function.
- */
-declare type Take<N extends number, T extends readonly unknown[], Acc extends readonly unknown[] = []> = Acc['length'] extends N ? Acc : T extends readonly [infer H, ...infer R] ? Take<N, R, readonly [...Acc, H]> : Acc;
-
-/**
- * Throttles a function. By default, leading and trailing are both true (lodash-like behavior).
- * The function is invoked at the leading edge and trailing edge of the throttle period.
- *
- * Example:
- * const fn = () => ...
- * const t = throttle(fn, 700);
- * const leadingOnly = throttle(fn, 700, { trailing: false });
- */
-export declare function throttle<T extends Fn>(fn: T, delay?: number, options?: ThrottleOptions): Throttled<T>;
-
-export declare type Throttled<T extends Fn> = ((this: ThisParameterType<T>, ...args: Parameters<T>) => void) & {
-    cancel(): void;
-    flush(): ReturnType<T> | undefined;
-    pending(): boolean;
-};
-
-export declare type ThrottleOptions = {
-    leading?: boolean;
-    trailing?: boolean;
-};
-
-/**
- * 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.
- *
- * @throws {TypeError} If str is not a string or limit is not a positive number.
- */
-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][];
-
-/**
- * Waits for a condition to become true by polling.
- * Useful for waiting for DOM elements, API states, or other conditions.
- *
- * @example
- * ```ts
- * // Wait for an element to appear
- * await waitFor(() => document.querySelector('#myElement') !== null);
- *
- * // Wait for API to be ready
- * await waitFor(
- *   async () => {
- *     const res = await fetch('/api/health');
- *     return res.ok;
- *   },
- *   { timeout: 30000, interval: 1000 }
- * );
- * ```
- *
- * @param condition - Function that returns true when condition is met
- * @param options - Configuration options
- * @param options.timeout - Maximum time to wait in ms (default: 5000)
- * @param options.interval - Polling interval in ms (default: 100)
- * @param options.signal - AbortSignal to cancel waiting
- * @returns Promise that resolves when condition becomes true
- * @throws {Error} If timeout is reached
- * @throws {DOMException} If aborted via signal
- */
-export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
-    timeout?: number;
-    interval?: number;
-    signal?: AbortSignal;
-}): Promise<void>;
-
-/**
- * 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 { }
+export * from './array/chunk';
+export * from './array/contains';
+export * from './array/fold';
+export * from './array/group';
+export * from './array/keyBy';
+export * from './array/list';
+export * from './array/pick';
+export * from './array/remoteList';
+export * from './array/replace';
+export * from './array/rotate';
+export * from './array/search';
+export * from './array/select';
+export * from './array/sort';
+export * from './array/toggle';
+export * from './array/uniq';
+export * from './async/attempt';
+export * from './async/defer';
+export * from './async/parallel';
+export * from './async/scheduler';
+export * from './async/pool';
+export * from './async/queue';
+export * from './async/race';
+export * from './async/retry';
+export * from './async/sleep';
+export * from './async/waitFor';
+export * from './date/expires';
+export * from './date/interval';
+export * from './date/timeDiff';
+export * from './function/assert';
+export * from './function/assertParams';
+export * from './function/compare';
+export * from './function/compareBy';
+export * from './function/compose';
+export * from './function/curry';
+export * from './function/debounce';
+export * from './function/fp';
+export * from './function/memo';
+export * from './function/once';
+export * from './function/pipe';
+export * from './function/throttle';
+export * from './math/abs';
+export * from './math/allocate';
+export * from './math/average';
+export * from './math/clamp';
+export * from './math/distribute';
+export * from './math/linspace';
+export * from './math/max';
+export * from './math/median';
+export * from './math/min';
+export * from './math/percent';
+export * from './math/range';
+export * from './math/round';
+export * from './math/sum';
+export * from './money/currency';
+export * from './money/exchange';
+export * from './money/types';
+export * from './object/stash';
+export * from './object/diff';
+export * from './object/merge';
+export * from './object/parseJSON';
+export * from './object/path';
+export * from './object/proxy';
+export * from './object/prune';
+export * from './object/seek';
+export * from './random/draw';
+export * from './random/random';
+export * from './random/shuffle';
+export * from './random/uuid';
+export * from './string/camelCase';
+export * from './string/kebabCase';
+export * from './string/pascalCase';
+export * from './string/similarity';
+export * from './string/snakeCase';
+export * from './string/truncate';
+export * from './typed/is';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map