@andrew_l/toolkit 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,3725 @@
+import * as lodash from 'lodash';
+
+type ItemType<T> = T extends Array<infer X> ? X : T extends string ? string : Exclude<T, null | undefined>;
+/**
+ * Converts a value into an array. This function handles different types of input,
+ * converting them to arrays as follows:
+ * - If the value is already an array, it returns it as-is.
+ * - If the value is a string, it splits the string by commas and trims the elements.
+ * - If the value is null or undefined, it returns an empty array.
+ * - Otherwise, it wraps the value in an array.
+ *
+ * @example
+ * arrayable(42); // [42]
+ * arrayable('a, b, c'); // ['a', 'b', 'c']
+ * arrayable([1, 2, 3]); // [1, 2, 3]
+ * arrayable(null); // []
+ * arrayable(undefined); // []
+ *
+ * @param value The value to convert into an array. It can be of any type.
+ * @returns An array derived from the input value.
+ *
+ * @group Array
+ */
+declare function arrayable<T>(value: Readonly<T>): ItemType<T>[];
+
+/**
+ * Calculates the average value from an array of numbers.
+ *
+ * The function sums up all valid numbers in the array and divides by the count of those valid numbers.
+ * If the array is empty or contains no valid numbers, it returns `0`.
+ *
+ * @example
+ * avg([5, 5, 5]); // 5
+ * avg([10, 20, 30]); // 20
+ * avg([1, 2, 'three', 4]); // 2.33 (ignores non-numeric values)
+ * avg([]); // 0
+ *
+ * @param values An array of numbers (could include invalid values, which will be ignored).
+ * @returns The average value of the valid numbers in the array, or `0` if no valid numbers exist.
+ *
+ * @group Array
+ */
+declare const avg: (values: readonly number[]) => number;
+
+/**
+ * Splits an array into smaller sub-arrays (chunks) of a specified size.
+ *
+ * If the array can't be evenly divided, the last chunk will contain the remaining elements.
+ *
+ * @example
+ * const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ * const chunkSize = 3;
+ * const result = chunk(data, chunkSize);
+ * console.log(result);
+ * // [
+ * //    [1, 2, 3],
+ * //    [4, 5, 6],
+ * //    [7, 8, 9]
+ * // ]
+ *
+ * @example
+ * const data = [1, 2, 3, 4, 5];
+ * const chunkSize = 2;
+ * const result = chunk(data, chunkSize);
+ * console.log(result);
+ * // [
+ * //    [1, 2],
+ * //    [3, 4],
+ * //    [5]
+ * // ]
+ *
+ * @param list The array to be split into chunks.
+ * @param size The size of each chunk. Defaults to `1` if not specified.
+ * @returns An array of arrays (chunks), each containing up to `size` elements from the original array.
+ *
+ * @group Array
+ */
+declare function chunk<T>(list: readonly T[], size?: number): T[][];
+
+/**
+ * Collapses a continuous series into a tuple of two elements.
+ *
+ * Where the first element is the beginning of the series.
+ * Where the second element is the end of the series.
+ *
+ * ⚠️ Tuple may consist only one element if the series not started, like: [1, 3] => [[1], [3]]
+ *
+ * @example
+ * const numbers = [1, 2, 3, 8, 9, 10, 15];
+ *
+ * chunkSeries(numbers); // [[1, 3], [8, 10], [15]]
+ *
+ * @group Array
+ */
+declare function chunkSeries(list: number[], step?: number): number[][];
+
+type MaybePropertyKey<T> = T extends object
+  ? keyof T | PropertyKey
+  : PropertyKey;
+
+type PropertyKeyLiteralToType<T> = T extends string
+  ? string
+  : T extends number
+    ? number
+    : T extends symbol
+      ? symbol
+      : T;
+
+type IsPropertyKey<T, V, L> = T extends object
+  ? V extends keyof T
+    ? T[V]
+    : L
+  : PropertyKeyLiteralToType<L>;
+
+/**
+ * Maps each element of an array based on a provided key.
+ *
+ * @example
+ * const data = [
+ *     { id: 1, name: 'group 1' },
+ *     { id: 2, name: 'group 2' },
+ *     { id: 1, name: 'group 2' }
+ * ];
+ *
+ * const result = keyBy(data, 'id');
+ * console.log(Object.entries(result));
+ * // [
+ * //    [1, [{ id: 1, name: 'group 1' }, { id: 1, name: 'group 2' }],
+ * //    [2, { id: 2, name: 'group 2' }],
+ * // ]
+ *
+ * @group Array
+ */
+declare function keyBy<T, K extends MaybePropertyKey<T>>(array: readonly T[], keyBy: K, objectMode?: false): Map<IsPropertyKey<T, K, K>, T>;
+declare function keyBy<T, K>(array: readonly T[], keyBy: (item: T) => K, objectMode?: false): Map<K, T>;
+declare function keyBy<T, K extends MaybePropertyKey<T>>(array: readonly T[], keyBy: K, objectMode: true): Record<K, T>;
+declare function keyBy<T, K extends PropertyKey>(array: readonly T[], keyBy: (item: T) => K, objectMode: true): Record<K, T>;
+
+/**
+ * Sort array by multiple fields
+ *
+ * @example
+ * // Sample data: an array of objects representing users
+ * const users = [
+ *   { name: 'Alice', age: 30, score: 85 },
+ *   { name: 'Bob', age: 25, score: 90 },
+ *   { name: 'Charlie', age: 35, score: 90 },
+ *   { name: 'Dave', age: 30, score: 70 },
+ * ];
+ *
+ * // Sort users first by score in descending order, then by age in ascending order
+ * const sortedUsers = orderBy(users, ['score', 'age'], ['desc', 'asc']);
+ *
+ * // Output the sorted array
+ * console.log(sortedUsers);
+ *
+ * @group Array
+ */
+declare function orderBy<T>(array: readonly T[], fields: (string | ((item: T) => any))[], orders: ('asc' | 'desc')[]): readonly T[];
+
+/**
+ * Sums the values in an array of numbers, ignoring non-numeric values.
+ *
+ * This function adds all valid numbers in the array and returns the sum.
+ * Non-numeric values (e.g., `null`, `undefined`, `NaN` are ignored in the sum.
+ *
+ * @example
+ * sum([2, 2]); // 4
+ * sum([1, 'a', 3, 4]); // 8 (non-numeric 'a' is ignored)
+ * sum([5, null, 10]); // 15 (null is ignored)
+ * sum([]); // 0 (empty array returns 0)
+ *
+ * @param values The array of numbers to be summed.
+ * @returns The sum of the numbers in the array.
+ *
+ * @group Array
+ */
+declare const sum: (values: readonly number[]) => number;
+
+/**
+ * Creates an array of unique values from all given arrays.
+ *
+ * This function takes two arrays, merges them into a single array, and returns a new array
+ * containing only the unique values from the merged array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} arr1 - The first array to merge and filter for unique values.
+ * @param {T[]} arr2 - The second array to merge and filter for unique values.
+ * @returns {T[]} A new array of unique values.
+ *
+ * @example
+ * const array1 = [1, 2, 3];
+ * const array2 = [3, 4, 5];
+ * const result = union(array1, array2);
+ * // result will be [1, 2, 3, 4, 5]
+ *
+ * @group Array
+ */
+declare function union<T>(arr1: readonly T[], arr2: readonly T[]): T[];
+
+/**
+ * Returns a new array with duplicates removed.
+ *
+ * This function creates a new array that contains only unique values,
+ * preserving the order of the original elements.
+ *
+ * @example
+ * uniq([1, 2, 3, 4, 1, 3]); // [1, 2, 3, 4]
+ * uniq([5, 5, 5, 5, 5]); // [5]
+ * uniq(['a', 'b', 'a', 'c']); // ['a', 'b', 'c']
+ * uniq([]); // [] (returns an empty array for empty input)
+ *
+ * @param value The array from which duplicates will be removed.
+ * @returns A new array containing only the unique values from the input array.
+ *
+ * @group Array
+ */
+declare function uniq<T extends any[]>(value: T): T;
+
+/**
+ * Extracts unique elements from an array based on a comparator function or property key.
+ *
+ * This function allows you to determine uniqueness based on custom criteria by passing
+ * a comparator function or a property key. The function will return a new array containing
+ * only the first occurrence of elements that are unique according to the specified comparator.
+ * If the comparator is a property key, uniqueness will be determined based on the value
+ * of that property.
+ *
+ * @example
+ * const users = [
+ *     { id: 1, role: 'admin' },
+ *     { id: 2, role: 'admin' },
+ *     { id: 3, role: 'user' },
+ *     { id: 4, role: 'user' },
+ * ];
+ *
+ * const uniqRoles = uniqBy(users, (v) => v.role);
+ * // [
+ * //     { id: 1, role: 'admin' },
+ * //     { id: 3, role: 'user' },
+ * // ]
+ *
+ * @example
+ * const products = [
+ *     { id: 1, category: 'electronics', name: 'Phone' },
+ *     { id: 2, category: 'electronics', name: 'Laptop' },
+ *     { id: 3, category: 'furniture', name: 'Sofa' },
+ * ];
+ *
+ * const uniqCategories = uniqBy(products, 'category');
+ * // [
+ * //     { id: 1, category: 'electronics', name: 'Phone' },
+ * //     { id: 3, category: 'furniture', name: 'Sofa' },
+ * // ]
+ *
+ * @param array The array to extract unique elements from.
+ * @param comparator A function that computes the value to determine uniqueness or a property key.
+ *                  If a string is passed, it is treated as a property key, and uniqueness is
+ *                  determined based on the value of that property.
+ * @returns A new array containing only the first occurrence of each unique element based on the comparator.
+ *
+ * @group Array
+ */
+declare function uniqBy<T>(array: T[], comparator: ((value: T) => any) | PropertyKey): T[];
+
+declare function ok(value: unknown, message?: string | Error): asserts value;
+declare function equal<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+declare function object(value: unknown, message?: string | Error): asserts value is object;
+declare function string(value: unknown, message?: string | Error): asserts value is string;
+declare function boolean(value: unknown, message?: string | Error): asserts value is boolean;
+declare function notEmptyString(value: unknown, message?: string | Error): asserts value is string;
+declare function number(value: unknown, message?: string | Error): asserts value is number;
+/**
+ * @param {unknown} value
+ * @param {string | Error} [message]
+ * @return {asserts value is Array}
+ */
+declare function array(value: unknown, message?: string | Error): asserts value is unknown[];
+declare function arrayStrings(value: unknown, message?: string | Error): asserts value is string[];
+declare function arrayNumbers(value: unknown, message?: string | Error): asserts value is number[];
+
+declare const assert_array: typeof array;
+declare const assert_arrayNumbers: typeof arrayNumbers;
+declare const assert_arrayStrings: typeof arrayStrings;
+declare const assert_boolean: typeof boolean;
+declare const assert_equal: typeof equal;
+declare const assert_notEmptyString: typeof notEmptyString;
+declare const assert_number: typeof number;
+declare const assert_object: typeof object;
+declare const assert_ok: typeof ok;
+declare const assert_string: typeof string;
+declare namespace assert {
+  export { assert_array as array, assert_arrayNumbers as arrayNumbers, assert_arrayStrings as arrayStrings, assert_boolean as boolean, assert_equal as equal, assert_notEmptyString as notEmptyString, assert_number as number, assert_object as object, assert_ok as ok, assert_string as string };
+}
+
+type Arrayable<T> = T[] | T;
+
+type Awaitable<T> = Promise<T> | T;
+
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+
+type FunctionArgs<Args extends any[] = any[], Return = void> = (
+  ...args: Args
+) => Return;
+
+type DeepPartial<T> = T extends object
+  ? { [P in keyof T]?: DeepPartial<T[P]> }
+  : T;
+
+type AnyFunction = (...args: any[]) => any;
+
+type Data = Record<string, unknown>;
+
+type GenericObject = Record<string, any>;
+
+type SelectOptions<T = any> = SelectOptionItem<T>[];
+
+type OverwriteWith<T1, T2> =
+  IsAny<T2> extends true ? T1 : Omit<T1, keyof T2> & T2;
+
+type IsAny<T> = boolean extends (T extends never ? true : false)
+  ? true
+  : false;
+
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
+/**
+ * @example
+ * LiteralUnion<'foo' | 'bar', string>
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/29729}
+ */
+type LiteralUnion<Union, Type> = Union | (Type & Nothing);
+
+interface Nothing {}
+
+type ValuesOfObject<T> = T[keyof T];
+
+type Fn = () => void;
+
+type PromisifyFn<T extends AnyFunction> = (
+  ...args: ArgumentsType<T>
+) => Promise<ReturnType<T>>;
+
+type TimeObject = {
+  h: number;
+  m: number;
+};
+
+interface ThemeConfig {
+  colors: {
+    [x: string]: Record<string, string>;
+  };
+  variables: {
+    [x: string]: Record<string, string | number>;
+  };
+}
+
+type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+interface SelectOptionItem<T = any> {
+  text: string;
+  value: T;
+  props?: any;
+}
+
+interface SelectOptionItem<T = any> {
+  text: string;
+  value: T;
+  props?: any;
+}
+
+type Primitive =
+  | null
+  | undefined
+  | string
+  | number
+  | bigint
+  | boolean
+  | symbol;
+
+type ExecResult<T extends Data = Data, K extends Data = Data> =
+  | ExecSuccess<T>
+  | ExecSkip<K>;
+
+type ExecSuccess<T extends Data = Data> = {
+  success: true;
+  code: string;
+  reason?: string;
+} & T;
+
+type ExecSkip<T extends Data = Data> = {
+  skip: true;
+  code: string;
+  reason?: string;
+} & T;
+
+type ExecResultToSuccess<T> =
+  T extends ExecSuccess<infer X> ? ExecSuccess<X> : ExecSuccess;
+
+type ExecResultToSkip<T> =
+  T extends ExecSkip<infer X> ? ExecSkip<X> : ExecSkip;
+
+interface Logger {
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+  extend: (...args: unknown[]) => void;
+}
+
+interface ArgToKeyOptions {
+    /**
+     * Object key generation strategy.
+     *
+     * When `json` we will use `JSON.stringify` which not quite effective.
+     * Also may not hit into cache when object has different key order.
+     *
+     * When `ref` we will use WeakMap to store object key which more effective but may produce unexpected cache hit.
+     *
+     * @default `ref`
+     */
+    objectStrategy: 'json' | 'ref';
+}
+
+interface CreateWithCacheOptions<T extends AnyFunction> extends Partial<ArgToKeyOptions> {
+    getBucket: (pointer: WithCachePointer) => WithCacheStorage;
+    getPointer: () => WithCachePointer;
+    fn: T;
+}
+type WithCachePointer = object | Function | symbol;
+interface WithCacheStorage {
+    get(key: unknown): unknown;
+    has(key: unknown): boolean;
+    delete(key: unknown): void;
+    set(key: unknown, value: unknown): void;
+}
+interface WithCache {
+    $cache: {
+        getBucket: () => WithCacheStorage;
+        getPointer: () => WithCachePointer;
+        argToKeyOptions: ArgToKeyOptions;
+    };
+}
+type WithCacheResult<T extends AnyFunction> = T & WithCache;
+declare function createWithCache<T extends AnyFunction>({ fn, getPointer, getBucket, objectStrategy, }: CreateWithCacheOptions<T>): WithCacheResult<T>;
+/**
+ * Returns true when function is cached
+ * @group Cache
+ */
+declare function isWithCache(value: unknown): value is WithCacheResult<AnyFunction>;
+
+/**
+ * Drop cached result
+ *
+ * @example
+ * const findUser = withCache((id: number) => db.users.findById(id));
+ *
+ * dropCache(findUser, 100500);
+ *
+ * @group Cache
+ */
+declare function dropCache(cachePointer: WithCachePointer, ...args: any[]): boolean;
+
+/**
+ * A Map-like class with a fixed capacity, where entries are automatically removed
+ * when the capacity is exceeded. This allows for efficient caching behavior,
+ * ensuring that the map never grows beyond the specified capacity.
+ *
+ * When the map reaches its capacity, the oldest entries (in insertion order)
+ * are removed to make room for new ones.
+ *
+ * @example
+ * const cache = new FixedMap<string, number>(3);
+ * cache.set('a', 1);
+ * cache.set('b', 2);
+ * cache.set('c', 3);
+ * cache.set('d', 4); // 'a' will be evicted, as it's the oldest entry
+ *
+ * console.log(cache.get('a')); // undefined
+ * console.log(cache.get('b')); // 2
+ *
+ * @group Cache
+ */
+declare class FixedMap<K = any, V = any> extends Map<K, V> {
+    private _capacity;
+    private _tail;
+    constructor(_capacity: number);
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    get capacity(): number;
+    set capacity(value: number);
+    private _drain;
+}
+
+/**
+ * A `WeakMap`-like class with a fixed capacity. Entries are automatically removed
+ * when the map exceeds the specified capacity. Unlike a regular `WeakMap`, the
+ * entries are limited to a defined size, and the oldest entries are evicted when
+ * new ones are added after the capacity is reached.
+ *
+ * This class behaves similarly to a `WeakMap`, but with the additional constraint
+ * of a fixed size. It automatically removes the least recently added key-value
+ * pairs when the map grows beyond the specified capacity.
+ *
+ * @example
+ * const cache = new FixedWeakMap<object, number>(3);
+ * const obj1 = { id: 1 };
+ * const obj2 = { id: 2 };
+ * const obj3 = { id: 3 };
+ *
+ * cache.set(obj1, 1);
+ * cache.set(obj2, 2);
+ * cache.set(obj3, 3);
+ *
+ * const obj4 = { id: 4 };
+ * cache.set(obj4, 4); // obj1 will be evicted as it's the oldest
+ *
+ * console.log(cache.get(obj1)); // undefined
+ * console.log(cache.get(obj2)); // 2
+ * console.log(cache.get(obj4)); // 4
+ *
+ * @group Cache
+ */
+declare class FixedWeakMap<K extends WeakKey = WeakKey, V = any> extends WeakMap<K, V> {
+    private _capacity;
+    private _tail;
+    constructor(_capacity: number);
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+    set capacity(value: number);
+    private _drain;
+}
+
+/**
+ * Check if function has cached result
+ *
+ * @example
+ * const findUser = withCache((id: number) => db.users.findById(id));
+ *
+ * const user = findUser(100500);
+ *
+ * isCached(findUser, 100500); // true
+ *
+ * @group Cache
+ */
+declare function isCached<T extends AnyFunction>(fn: AnyFunction, ...args: Parameters<T>): boolean;
+
+/**
+ * A simple implementation of a Least Recently Used (LRU) cache. This cache stores
+ * key-value pairs and ensures that the most recently accessed items are kept
+ * in the cache, while the least recently used items are evicted when the cache
+ * reaches its capacity.
+ *
+ * The cache is implemented as a doubly linked list where the head represents
+ * the most recently accessed item, and the tail represents the least recently
+ * accessed item. When the cache is full, the least recently used item (tail)
+ * is removed to make space for new items.
+ *
+ * @group Cache
+ */
+declare class LruCache<TKey = any, TValue = any> {
+    private capacity;
+    private items;
+    private forward;
+    private backward;
+    private K;
+    private V;
+    size: number;
+    private head;
+    private tail;
+    constructor(capacity: number);
+    /**
+     * Method used to clear the structure.
+     */
+    clear(): void;
+    set(key: TKey, value: TValue): this;
+    has(key: TKey): boolean;
+    delete(key: TKey): void;
+    get(key: TKey): TValue | undefined;
+    /**
+     * Method used to get the value attached to the given key. Does not modify
+     * the ordering of the underlying linked list.
+     */
+    peek(key: TKey): TValue | undefined;
+    /**
+     * Method used to create an iterator over the cache's keys from most
+     * recently used to least recently used.
+     */
+    keys(): IterableIterator<TKey>;
+    /**
+     * Method used to create an iterator over the cache's values from most
+     * recently used to least recently used.
+     *
+     */
+    values(): IterableIterator<TValue>;
+    /**
+     * Method used to create an iterator over the cache's entries from most
+     * recently used to least recently used.
+     *
+     * @return {IterableIterator<[TKey, TValue | undefined]>}
+     */
+    entries(): {
+        [Symbol.iterator](): any;
+        next(): {
+            done: boolean;
+            value: undefined;
+        } | {
+            done: boolean;
+            value: (TKey | TValue | undefined)[];
+        };
+    };
+    /**
+     * Method used to splay a value on top.
+     *
+     * @param  {number}   pointer - Pointer of the value to splay on top.
+     */
+    splayOnTop(pointer: number): this;
+    [Symbol.iterator](): {
+        [Symbol.iterator](): any;
+        next(): {
+            done: boolean;
+            value: undefined;
+        } | {
+            done: boolean;
+            value: (TKey | TValue | undefined)[];
+        };
+    };
+}
+
+interface TimeBucketOptions {
+    /**
+     * The size of each time bucket in milliseconds. This is the interval at which
+     * the records in the bucket will expire and be dropped.
+     */
+    sizeMs: number;
+    /**
+     * The maximum number of entries the bucket can hold. Once the capacity is
+     * reached, the least recently used entry will be removed.
+     * @default Infinity
+     */
+    capacity?: number;
+}
+/**
+ * A time-based bucket that holds records for a specific interval defined by `sizeMs`.
+ * The records in the bucket will be dropped once the interval elapses, based on the
+ * current time. The `TimeBucket` is designed to avoid using timers to track expirations.
+ *
+ * It can be used to store data that expires over fixed time intervals (e.g., caching,
+ * throttling).
+ *
+ * @example
+ * const bucket = new TimeBucket({ sizeMs: 1000, capacity: 10 });
+ * bucket.set('key1', 'value1');
+ * console.log(bucket.get('key1')); // 'value1'
+ *
+ * // After 1 second, the bucket will drop the expired records.
+ *
+ * @group Cache
+ */
+declare class TimeBucket<K = any, V = any> {
+    private _pointer;
+    private _sizeMs;
+    private _bucket;
+    constructor({ capacity, sizeMs }: TimeBucketOptions);
+    get capacity(): number;
+    get sizeMs(): number;
+    set sizeMs(value: number);
+    get size(): number;
+    set(key: K, value: V): this;
+    get(key: K): any | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callbackfn: (value: V, key: K, map: TimeBucket<K, V>) => void, thisArg?: any): void;
+    private _drainBucket;
+}
+
+interface WithCacheOptions extends Partial<ArgToKeyOptions> {
+    /**
+     * Custom cache pointer
+     */
+    cachePointer?: WithCachePointer;
+}
+declare const cache: WeakMap<WithCachePointer, Map<string, any>>;
+/**
+ * Wrap a function to cache results by arguments
+ *
+ * @example
+ * const sum = withCache((a, b) => {
+ *     console.log('calc?');
+ *     return a + b;
+ * });
+ *
+ * sum(1, 2); // calc?
+ * sum(1, 2);
+ * sum(1, 3)  // calc?
+ *
+ * @group Cache
+ */
+declare function withCache<T extends AnyFunction>(fn: T): WithCacheResult<T>;
+declare function withCache<T extends AnyFunction>(options: WithCacheOptions, fn: T): WithCacheResult<T>;
+
+interface WithCacheBucketOptions extends Partial<ArgToKeyOptions> {
+    /**
+     * Define cached records drops interval.
+     */
+    sizeMs: number;
+    /**
+     * Capacity of cached records
+     */
+    capacity?: number;
+    /**
+     * Custom cache pointer
+     */
+    cachePointer?: WithCachePointer;
+}
+declare const cacheBucket: WeakMap<WithCachePointer, TimeBucket<string, any>>;
+/**
+ * Wrap a function to cache results by arguments
+ *
+ * But with time and capacity limitation
+ *
+ * @example
+ * const sum = withCacheBucket({ capacity: 1, sizeMs: 1000000 }, (a, b) => {
+ *     console.log('calc?');
+ *     return a + b;
+ * });
+ *
+ * sum(1, 2); // calc?
+ * sum(1, 2);
+ * sum(1, 3)  // calc?
+ * sum(1, 3)
+ * sum(1, 2); // calc?
+ *
+ * @group Cache
+ */
+declare function withCacheBucket<T extends AnyFunction>({ capacity, sizeMs, cachePointer, ...options }: WithCacheBucketOptions, fn: T): WithCacheResult<T>;
+
+interface WithCacheBucketBatchOptions<T extends object, K extends keyof T> {
+    /**
+     * Define cached records drops interval.
+     */
+    sizeMs: number;
+    /**
+     * Cache record by object key.
+     */
+    key: K;
+    /**
+     * Amount of items which will handled by resolver function.
+     */
+    batchSize?: number;
+    /**
+     * Capacity of cached records
+     */
+    capacity?: number;
+    /**
+     * Custom cache pointer
+     */
+    cachePointer?: WithCachePointer;
+    /**
+     * Should we retry resolving for provided item key when previously we got empty result.
+     */
+    retryEmpty?: boolean;
+    /**
+     * Resolving item function
+     */
+    resolver?: (values: T[K][]) => Promise<T[]>;
+}
+/**
+ * In this way we will cache item of resulted array by `key`.
+ *
+ * Useful when we need for example fetch batch of users by ids but took already cached results if it available.
+ *
+ * @example TODO
+ *
+ * @beta
+ *
+ * @group Cache
+ */
+declare function withCacheBucketBatch<T extends object, K extends keyof T>({ capacity, sizeMs, key, batchSize, cachePointer, retryEmpty, }: WithCacheBucketBatchOptions<T, K>, resolver: (values: T[K][]) => Promise<T[]>): WithCacheResult<(values: T[K][]) => Promise<Map<string, Readonly<T>>>>;
+
+interface WithCacheFixedOptions extends Partial<ArgToKeyOptions> {
+    /**
+     * Capacity of cached records
+     */
+    capacity: number;
+    /**
+     * Custom cache pointer
+     */
+    cachePointer?: WithCachePointer;
+}
+declare const cacheFixed: WeakMap<WithCachePointer, FixedMap<string, any>>;
+/**
+ * Wrap a function to cache results by arguments
+ *
+ * But with capacity limitation
+ *
+ * @example
+ * const sum = withCacheFixed({ capacity: 1 }, (a, b) => {
+ *     console.log('calc?');
+ *     return a + b;
+ * });
+ *
+ * sum(1, 2); // calc?
+ * sum(1, 2);
+ * sum(1, 3)  // calc?
+ * sum(1, 3)
+ * sum(1, 2); // calc?
+ *
+ * @group Cache
+ */
+declare function withCacheFixed<T extends AnyFunction>({ capacity, cachePointer, ...options }: WithCacheFixedOptions, fn: T): WithCacheResult<T>;
+
+interface WithCacheLruOptions extends Partial<ArgToKeyOptions> {
+    capacity: number;
+    cachePointer?: WithCachePointer;
+}
+declare const cacheLRU: WeakMap<WithCachePointer, LruCache<string, any>>;
+/**
+ * Wrap a function to cache results by arguments
+ *
+ * But with LRU
+ *
+ * @example
+ * const sum = withCacheLRU({ capacity: 100 }, (a, b) => {
+ *     console.log('calc?');
+ *     return a + b;
+ * });
+ *
+ * sum(1, 2); // calc?
+ * sum(1, 2);
+ *
+ * @group Cache
+ */
+declare function withCacheLRU<T extends AnyFunction>({ capacity, cachePointer, ...options }: WithCacheLruOptions, fn: T): WithCacheResult<T>;
+
+/**
+ * Make deep cloning of function result before returning.
+ *
+ * @example
+ * const findUser = withDeepClone(
+ *   withCache((id: number) => {
+ *     return { id, name: 'Andrew' };
+ *   })
+ * );
+ *
+ * const user1 = findUser(100500);
+ * const user2 = findUser(100500);
+ * user1.name = 'ABC';
+ *
+ * console.log(user1.name); // ABC
+ * console.log(user2.name); // Andrew
+ *
+ * @group Cache
+ */
+declare function withDeepClone<T extends AnyFunction>(fn: T): T;
+
+/**
+ * @example TODO
+ * @group Cache
+ * @beta
+ */
+declare function withPointerCache<T>(pointer: object, dependencies: string[], fn: () => T): T;
+
+/**
+ * Capture stack trace till the function and returns as a `string`
+ *
+ * @example
+ *
+ * function main() {
+ *   const userId = getUserId();
+ * }
+ *
+ * function getUserId() {
+ *   const stackTrace = captureStackTrace(doCoolStuff);
+ *   console.warn('Please, use getAccountId instead.', stackTrace);
+ * }
+ *
+ * @group Errors
+ */
+declare function captureStackTrace(till: AnyFunction): string;
+
+type ToCatchResult<T> = T extends Promise<any> ? Promise<CatchSuccessResult<Awaited<T>> | CatchErrorResult> : CatchSuccessResult<T> | CatchErrorResult;
+type CatchErrorResult = [Error, undefined];
+type CatchSuccessResult<T> = [undefined, T];
+/**
+ * You're tired to write `try... catch`, and so are we.
+ *
+ * Also supports `async/await`
+ *
+ * @example
+ * const [err, result] = catchError(() => {
+ *   // danger code
+ * });
+ *
+ * @group Errors
+ */
+declare function catchError<T>(fn: () => T): ToCatchResult<T>;
+
+declare namespace Color {
+    /**
+     * From 0 to 1
+     */
+    type Alpha = number;
+    type HSLA = {
+        h: number;
+        s: number;
+        l: number;
+        a: Alpha;
+    };
+    type RGBA = {
+        r: number;
+        g: number;
+        b: number;
+        a: Alpha;
+    };
+    type HEX = string;
+    /**
+     * Unified color representation in [red, green, blue, alpha]
+     */
+    type ColorChannels = [number, number, number, number];
+}
+
+declare function parseHEX(value: unknown): Color.ColorChannels | null;
+
+/**
+ * Parse a string as a hsl color
+ */
+declare function parseHSL(value: string): Color.HSLA | null;
+
+declare function parseRGB(value: unknown): Color.RGBA | null;
+
+/**
+ * Check if provided value represents color channels
+ * @group Colors
+ */
+declare function isColorChannels(value: unknown): value is Color.ColorChannels;
+
+/**
+ * Returns css valid color with adjusted alpha channel
+ *
+ * @example
+ * alpha('rgba(0, 0, 0, 0.87)', 1); // 'rgba(0, 0, 0, 1)'
+ *
+ * @group Colors
+ */
+declare function alpha(color: string | Color.ColorChannels, newAlpha: number): string;
+
+/**
+ * Just mixing of two colors
+ *
+ * @example
+ * const colorA = 'rgb(50, 100, 100)';
+ * const colorB = 'rgb(150, 0, 0)';
+ *
+ * // [100, 50, 50, 1]
+ * blendColors(colorA, colorB, 0.5);
+ *
+ * @group Colors
+ */
+declare function blendColors(color1: Color.ColorChannels | string, color2: Color.ColorChannels | string, factor: number): Color.ColorChannels;
+
+/**
+ * Build css valid color from color channels
+ *
+ * @example
+ * const channels = [255, 255, 255, 0.5];
+ *
+ * buildCssColor(channels); // 'rgba(255, 255, 255, 0.5)'
+ *
+ * // with applied opacity factor
+ * buildCssColor(channels, 0.1); // 'rgba(255, 255, 255, 0.05)'
+ *
+ * @group Colors
+ */
+declare function buildCssColor([r, g, b, a]: Color.ColorChannels, opacity?: number): string;
+
+/**
+ * Converts color channels into hex
+ *
+ * @example
+ * const channels = [255, 255, 255, 1];
+ *
+ * // with alpha channel
+ * channelsToHex(channels); // '#FFFFFFFF'
+ *
+ * // without alpha channel
+ * channelsToHex(channels, false); // '#FFFFFF'
+ * @group Colors
+ */
+declare function channelsToHex(channels: Color.ColorChannels, withAlpha?: boolean): string;
+
+/**
+ * Converts color channels into HSL
+ * @group Colors
+ */
+declare function channelsToHSL([r, g, b, a]: Color.ColorChannels): Color.HSLA;
+
+/**
+ * Converts color channels into RGB
+ * @group Colors
+ */
+declare function channelsToRGB([r, g, b, a]: Color.ColorChannels): Color.RGBA;
+
+/**
+ * Parse css color and returns color channels
+ * @group Colors
+ */
+declare function colorToChannels(color: string | Color.ColorChannels): Color.ColorChannels;
+
+/**
+ * Calculate WCAG 2.0 contrast ratio of two luminance
+ *
+ * @example
+ * const l1 = luminance([255, 255, 255, 1]);
+ * const l2 = luminance([0, 0, 0, 1]);
+ *
+ * contrastRatio(l1, l2); // 21
+ *
+ * @group Colors
+ */
+declare function contrastRatio(l1: number, l2: number): number;
+
+/**
+ * Create a getter of css variable for container
+ * @group Colors
+ */
+declare function cssVariable(container: HTMLElement): (name: string) => string;
+
+/**
+ * Parsing hex string as color channels
+ *
+ * @example
+ * hexToChannels('#FFFFFF'); // [255, 255, 255, 1]
+ * hexToChannels('#FFF'); // [255, 255, 255, 1]
+ *
+ * @group Colors
+ */
+declare function hexToChannels(hexWithAlpha: string): Color.ColorChannels;
+
+/**
+ * Parsing HSL string as color channels
+ *
+ * @example
+ * // [128, 51, 204, 0.15]
+ * hslToChannels('hsl(270 60% 50% / 15%)');
+ *
+ * @group Colors
+ */
+declare function hslToChannels(value: string): Color.ColorChannels;
+
+/**
+ * Linear color interpolating
+ *
+ * @example
+ * // 'rgba(50, 50, 50, 1)'
+ * interpolateColor(
+ *   'rgb(0, 0, 0)',
+ *   'rgb(100, 100, 100)',
+ *   0.5
+ * );
+ *
+ * @group Colors
+ */
+declare function interpolateColor(color1: string | Color.ColorChannels, color2: string | Color.ColorChannels, factor: number): Color.ColorChannels;
+
+/**
+ * Calculate luminance of color
+ *
+ * @example
+ * luminance([255, 255, 255, 1]); // 1
+ * luminance([0, 0, 0, 1]); // 0
+ *
+ * @group Colors
+ */
+declare function luminance([r, g, b]: Color.ColorChannels): number;
+
+/**
+ * Parse alpha channel value and normalize it from 0 to 1
+ *
+ * @param value Value to be parsed
+ * @param fallback Value which will be used as fallback when failed to parse
+ *
+ * @example
+ * parseAlpha('0.1'); // 0.1
+ * parseAlpha('10%'); // 0.1
+ * parseAlpha(0.1); // 0.1
+ *
+ * @group Colors
+ */
+declare function parseAlpha(value: unknown, fallback?: number): number;
+
+/**
+ * Parsing rgb() string as color channels
+ *
+ * @example
+ * // [255, 0, 0, 0.2]
+ * rgbToChannels('rgba(100% 0% 0% / 20%)');
+ *
+ * @group Colors
+ */
+declare function rgbToChannels(value: string): Color.ColorChannels;
+
+/**
+ * Returns a color text color that should be on background to keep good contrast
+ *
+ * @example
+ * const bgColor = 'rgb(255, 255, 255)';
+ * const tint = 1;
+ *
+ * // 'rgba(0, 0, 0, 1)'
+ * const textColor = tintedTextColor(bgColor, tint);
+ *
+ * @group Colors
+ */
+declare function tintedTextColor(background: string | Color.ColorChannels, tintPercentage?: number): Color.ColorChannels;
+
+type ColorChannels = Color.ColorChannels;
+/**
+ * General color parser api
+ * @group Colors
+ */
+declare const ColorParser: {
+    HSL: typeof parseHSL;
+    RGB: typeof parseRGB;
+    HEX: typeof parseHEX;
+};
+
+/**
+ * Calculate crc32 hash from string
+ * @group Crypto
+ */
+declare function crc32(str: string, seed?: number): number;
+
+type Dict<T> = {
+    [key: string]: T | undefined;
+};
+type ListTypeName = 'bool' | 'int' | 'decimal' | 'string';
+type ListTypeNameToType<T extends ListTypeName> = T extends 'bool' ? boolean : T extends 'int' ? number : T extends 'decimal' ? number : T extends 'string' ? string : never;
+/**
+ * Environment variable parser
+ *
+ * @group Environment
+ */
+interface EnvParser {
+    /**
+     * NODE_ENV is `development`
+     */
+    isDevelopment: boolean;
+    /**
+     * NODE_ENV is `production`
+     */
+    isProduction: boolean;
+    /**
+     * NODE_ENV is `stage`
+     */
+    isStage: boolean;
+    /**
+     * Returns `true` when environment key has set to `"true"`
+     *
+     * Returns `defaultValue` when key is not defined
+     */
+    bool(key: string, defaultValue?: boolean): boolean;
+    /**
+     * Returns `number` when environment key has correct number value.
+     *
+     * Returns `defaultValue` when environment key is not defined or has invalid number value
+     */
+    int(key: string, defaultValue?: number): number;
+    /**
+     * Returns `number` when environment key has correct number value.
+     *
+     * Returns `defaultValue` when environment key is not defined or has invalid number value
+     */
+    decimal(key: string, dights?: number, defaultValue?: number): number;
+    /**
+     * Returns `string` when environment key has defined.
+     *
+     * Returns `defaultValue` when environment key is not defined
+     */
+    string(key: string, defaultValue?: string): string;
+    /**
+     * Returns `array` of parsed environment value.
+     *
+     * Returns `defaultValue` when key is not defined
+     */
+    list<T extends ListTypeName>(key: string, itemType: T, defaultValue?: ListTypeNameToType<T>[]): ListTypeNameToType<T>[];
+    /**
+     * Returns parsed json value.
+     *
+     * Returns `defaultValue` when key is not defined or invalid json value
+     */
+    json<T = any>(key: string, defaultValue?: T | null): T | null;
+}
+/**
+ * Ready-to-use environment parser.
+ *
+ * Target: `process.env`
+ *
+ * Fallback: `import.meta.env`
+ *
+ * @example
+ *
+ * // env.string
+ * const API_KEY = env.string('API_KEY', 'test_key');
+ *
+ * // env.bool
+ * const TEST_FEATURE = env.bool('TEST_FEATURE', false);
+ *
+ * // env.int
+ * const RETRY_ATTEMPTS = env.int('RETRY_ATTEMPTS', 5);
+ *
+ * // env.decimal
+ * const DELAY_SECONDS = env.decimal('DELAY_SECONDS', 2, 5); // round to 2 dights
+ *
+ * // env.list
+ * const TARGET_ROLES = env.list('TARGET_ROLES', 'string', ['ADMIN']);
+ *
+ * // env.json
+ * const GOOGLE_CREDS = env.json<{ projectId: string; token: string; }>('GOOGLE_CREDS');
+ *
+ * @group Environment
+ */
+declare const env: Readonly<EnvParser>;
+/**
+ * @example
+ * const env = createEnvParser(process.env);
+ * // const env = createEnvParser(import.meta.env);
+ *
+ * const API_KEY = env.string('API_KEY', 'test_key');
+ *
+ * @group Environment
+ */
+declare function createEnvParser(targetObject: Record<string, string> | Dict<string>): Readonly<EnvParser>;
+
+/**
+ * Simple application error class with the code
+ * @group Errors
+ */
+declare class AppError extends Error {
+    code: number;
+    constructor(messageOrCode: string | number, code?: number, options?: ErrorOptions);
+    /**
+     * alias for `code` property
+     */
+    get statusCode(): number;
+    get name(): string;
+    static is(value: any): value is AppError;
+}
+
+/**
+ * Same as `AssertionError` but for browser env.
+ * @group Errors
+ */
+declare class BrowserAssertionError extends Error {
+    /**
+     * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
+     */
+    actual: unknown;
+    /**
+     * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
+     */
+    expected: unknown;
+    /**
+     * Set to the passed in operator value.
+     */
+    operator: string;
+    /**
+     * Indicates if the message was auto-generated (`true`) or not.
+     */
+    generatedMessage: boolean;
+    /**
+     * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
+     */
+    code: 'ERR_ASSERTION';
+    constructor(options?: {
+        /** If provided, the error message is set to this value. */
+        message?: string | undefined;
+        /** The `actual` property on the error instance. */
+        actual?: unknown | undefined;
+        /** The `expected` property on the error instance. */
+        expected?: unknown | undefined;
+        /** The `operator` property on the error instance. */
+        operator?: string | undefined;
+        /** If provided, the generated stack trace omits frames before this function. */
+        stackStartFn?: Function | undefined;
+    });
+}
+
+/**
+ * @group Utility Functions
+ */
+declare function isSuccess<T extends ExecResult>(value: T): value is ExecResultToSuccess<T>;
+/**
+ * @group Utility Functions
+ */
+declare function isSkip<T extends ExecResult>(value: T): value is ExecResultToSkip<T>;
+
+/**
+ * Extracts file extension from filename or url link
+ */
+declare function getFileExtension(name: string, withDot?: boolean): string | null;
+
+/**
+ * Extract filename from string
+ *
+ * @example
+ * getFileName('Andrew L - CV.pdf'); // 'Andrew L - CV'
+ *
+ * @group Files
+ */
+declare function getFileName(value: string): string | null;
+
+/**
+ * Converts bytes amount into human readably string
+ *
+ * @example
+ * humanFileSize(1024); // 1KB
+ *
+ * @group Files
+ */
+declare function humanFileSize(bytes: number, digits?: number, withSpace?: boolean): string;
+
+/**
+ * Determines if the window object is available in the global scope
+ *
+ * @group Predicates
+ */
+declare const isClient: boolean;
+/**
+ * Returns `true` when value is not `undefined`
+ * @group Predicates
+ */
+declare const isDef: <T = any>(val?: T) => val is T;
+/**
+ * Checks if the given value is a `null` or `undefined`
+ * @group Predicates
+ */
+declare function isNullOrUndefined(value: unknown): value is undefined | null;
+/**
+ * Checks if the given value is a `bigint`
+ * @group Predicates
+ */
+declare const isBigInt: (val: any) => val is bigint;
+/**
+ * Checks if the given value is a `boolean`
+ * @group Predicates
+ */
+declare const isBoolean: (val: any) => val is boolean;
+/**
+ * Checks if the given value is a `function`
+ * @group Predicates
+ */
+declare const isFunction: <T extends Function>(val: any) => val is T;
+/**
+ * Checks if the given value is a `number`
+ *
+ * @example
+ * console.log(isNumber(123)); // true
+ * console.log(isNumber('abc')); // false
+ * console.log(isNumber(NaN)); // false
+ *
+ * @group Predicates
+ */
+declare const isNumber: (val: any) => val is number;
+/**
+ * Checks if the given value is a `string`
+ * @group Predicates
+ */
+declare const isString: (val: unknown) => val is string;
+/**
+ * Checks if the given value is a plain `object`
+ * @group Predicates
+ */
+declare const isObject: (val: any) => val is object;
+/**
+ * Checks if the given value is valid `Date`
+ * @group Predicates
+ */
+declare const isDate: (val: any) => val is Date;
+/**
+ * Function that does nothing
+ * @group Utility Functions
+ */
+declare const noop: () => void;
+/**
+ * Checks if the given value is a `Error`
+ * @group Predicates
+ */
+declare const isError: (val: any) => val is Error;
+/**
+ * Checks if the given value is a `symbol`
+ * @group Predicates
+ */
+declare const isSymbol: (val: any) => val is Symbol;
+/**
+ * Checks if the given value is a `Set`.
+ * @group Predicates
+ */
+declare const isSet: <T = any>(val: any) => val is Set<T>;
+/**
+ * Checks if the given value is a `WeekSet`.
+ * @group Predicates
+ */
+declare const isWeakSet: <T extends WeakKey = any>(val: any) => val is WeakSet<T>;
+/**
+ * Checks if the given value is a `Map`.
+ * @group Predicates
+ */
+declare const isMap: <K = any, V = any>(val: any) => val is Map<K, V>;
+/**
+ * Checks if the given value is a `WeakMap`.
+ * @group Predicates
+ */
+declare const isWeakMap: <V = any>(val: any) => val is WeakMap<WeakKey, V>;
+/**
+ * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
+ *
+ * @param {unknown} a - The first value to compare.
+ * @param {unknown} b - The second value to compare.
+ * @returns {boolean} `true` if the values are equal, otherwise `false`.
+ *
+ * @example
+ * isEqual(1, 1); // true
+ * isEqual({ a: 1 }, { a: 1 }); // true
+ * isEqual(/abc/g, /abc/g); // true
+ * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
+ * isEqual([1, 2, 3], [1, 2, 3]); // true
+ *
+ * @group Predicates
+ */
+declare function isEqual(a: unknown, b: unknown): boolean;
+/**
+ * Checks if a given value is empty.
+ *
+ * Support for `Array`, `Object`, `string` `Map`, `Set`.
+ *
+ * @example
+ * isEmpty(); // true
+ * isEmpty(null); // true
+ * isEmpty(''); // true
+ * isEmpty([]); // true
+ * isEmpty({}); // true
+ * isEmpty(new Map()); // true
+ * isEmpty(new Set()); // true
+ * isEmpty('hello'); // false
+ * isEmpty([1, 2, 3]); // false
+ * isEmpty({ a: 1 }); // false
+ * isEmpty(new Map([['key', 'value']])); // false
+ * isEmpty(new Set([1, 2, 3])); // false
+ *
+ * @group Predicates
+ */
+declare const isEmpty: (obj: any) => boolean;
+/**
+ * Checks if the given value is a `Promise`
+ * @group Predicates
+ */
+declare function isPromise<T = void>(value: any): value is Promise<T>;
+/**
+ * Checks whether a value is a JavaScript primitive.
+ *
+ * JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints.
+ * @group Predicates
+ */
+declare const isPrimitive: (value: unknown) => value is Primitive;
+
+/**
+ * Create pretty simple `console.log` wrapper interface.
+ *
+ * @example
+ * const log = logger('UserService');
+ *
+ * log.info('Create user: %s', 'user_1'); // Create user: %s
+ *
+ * @group Utility Functions
+ */
+declare const logger: (...baseArgs: any[]) => Logger;
+
+/**
+ * Check if bits are set in `number` bitmask
+ *
+ * @example
+ * const scope = (1 << 1 | 1 << 2 | 1 << 3);
+ *
+ * checkBitmask(scope, 1 << 2); // true
+ * checkBitmask(scope, 1 << 5); // false
+ *
+ * @group Numbers
+ */
+declare function checkBitmask(scope: number, flag: number): boolean;
+/**
+ * Check if bits are set in `bigint` bitmask
+ *
+ * @example
+ * const scope = (1n << 1n | 1n << 2n | 1n << 3n);
+ *
+ * checkBitmask(scope, 1n << 2n); // true
+ * checkBitmask(scope, 1n << 5n); // false
+ *
+ * @group Numbers
+ */
+declare function checkBitmask(scope: bigint, flag: bigint): boolean;
+
+/**
+ * Rounds the given value to a specified range. If the value is less than the minimum,
+ * it returns the minimum. If the value is greater than the maximum, it returns the maximum.
+ * If the value is within the range, it returns the original value.
+ *
+ * @param {number} num - The number to be clamped.
+ * @param {number} min - The minimum value of the range.
+ * @param {number} max - The maximum value of the range.
+ * @returns {number} - The clamped value within the specified range.
+ *
+ * @example
+ * const min = 5;
+ * const max = 10;
+ *
+ * // Returns: 7 (within range)
+ * clamp(7, min, max);
+ *
+ * // Returns: 10 (clamped to max)
+ * clamp(15, min, max);
+ *
+ * // Returns: 5 (clamped to min)
+ * clamp(3, min, max);
+ *
+ * @group Numbers
+ */
+declare const clamp: (num: number, min: number, max: number) => number;
+
+interface RandomizerOptions {
+    min: number;
+    max: number;
+    pregenerateAmount: number;
+    transform: (value: number) => number;
+}
+declare class Randomizer {
+    private _pool;
+    private _step;
+    private _min;
+    private _max;
+    private _pregenerateAmount;
+    private _transform;
+    constructor({ min, max, pregenerateAmount, transform }: RandomizerOptions);
+    /**
+     * Returns the current step of the randomizer.
+     *
+     * @returns {number} The current step.
+     */
+    getCurrentStep(): number;
+    /**
+     * Sets the current step of the randomizer.
+     *
+     * @param {number} value - The step to set.
+     * @throws {Error} If the provided value is not a valid number or less than 0.
+     */
+    setCurrentStep(value: number): void;
+    /**
+     * Retrieves a random number either from the current step or a specific step if provided.
+     *
+     * @param {number} [fromStep] - The step from which to retrieve the random number (optional).
+     * @returns {number} The random number at the current or specified step.
+     */
+    get(fromStep?: number): number;
+    /**
+     * Resets the current step to 0.
+     */
+    resetStep(): void;
+    /**
+     * Resets the random number pool, clearing and repopulating it with new random values.
+     */
+    resetPool(): void;
+    private _rand;
+    private _lookup;
+}
+/**
+ * Creates a random number generator with step control and optional transformation.
+ * Allows caching of generated numbers for efficiency, with optional pregeneration and transformation.
+ *
+ * @param {RandomizerOptions} options - Configuration for the randomizer.
+ * @param {number} options.min - Minimum value for the random number.
+ * @param {number} options.max - Maximum value for the random number.
+ * @param {number} [options.pregenerateAmount=100] - Number of random numbers to pregenerate and cache.
+ * @param {(value: number) => number} [options.transform] - A function to transform the generated random number.
+ * @returns {Randomizer} - The randomizer object with step control and number generation.
+ *
+ *
+ * @example
+ * // Basic usage of the randomizer
+ * const randomizer = createRandomizer({
+ *   min: 1,
+ *   max: 10,
+ *   pregenerateAmount: 5
+ * });
+ *
+ * // Get the random number at the current step
+ * console.log(randomizer.get()); // e.g., returns 3
+ *
+ * // Get the random number at a specific step
+ * console.log(randomizer.get(2)); // e.g., returns 7
+ *
+ * // Get the current step
+ * console.log(randomizer.getCurrentStep()); // returns the current step (e.g., 1)
+ *
+ * // Set the current step to 3
+ * randomizer.setCurrentStep(3);
+ *
+ * // Get the random number at step 3
+ * console.log(randomizer.get()); // returns the value for step 3
+ *
+ * @example
+ * // Usage with a transformation function
+ * const randomizerWithTransform = createRandomizer({
+ *   min: 1,
+ *   max: 10,
+ *   pregenerateAmount: 5,
+ *   transform: (value) => value * 2
+ * });
+ *
+ * // Get a transformed random number at the current step
+ * console.log(randomizerWithTransform.get()); // e.g., returns 6 (original value 3 transformed by multiplying by 2)
+ *
+ * // Reset the step to 0
+ * randomizerWithTransform.resetStep();
+ * console.log(randomizerWithTransform.get()); // returns the random number at step 0
+ *
+ * @group Numbers
+ */
+declare function createRandomizer({ min, max, pregenerateAmount, transform, }: Partial<RandomizerOptions>): Randomizer;
+
+/**
+ * A class that allows you to calculate the running mean (average) of a set of numbers.
+ * It computes the average as new numbers are added and can also reset the progress.
+ *
+ * @example
+ * // Basic usage to calculate running mean
+ * const avg = findMean();
+ * avg.push(1, 2, 3);
+ * console.log(avg.value); // Output: 2 (average of 1, 2, 3)
+ *
+ * @example
+ * // Reset the calculation with an initial value
+ * const avg = findMean(10);
+ * avg.push(20);
+ * console.log(avg.value); // Output: 15 (average of 10, 20)
+ * console.log(avg.count); // Output: 2 (two values added)
+ */
+declare class FindMean {
+    #private;
+    constructor(initialValue?: number);
+    /**
+     * Resets the current progress of the mean calculation.
+     * Optionally, you can pass an initial value to start the calculation.
+     *
+     * @param {number} [initialValue] - The initial value to start the mean calculation with.
+     * @returns {FindMean} The current instance of the FindMean class for chaining.
+     *
+     * @example
+     * const avg = findMean();
+     * avg.push(2, 4);
+     * avg.reset();
+     * console.log(avg.value); // Output: 0
+     */
+    reset(initialValue?: number): FindMean;
+    /**
+     * Retrieves the current mean value (average).
+     *
+     * @returns {number} The current mean value.
+     *
+     * @example
+     * const avg = findMean();
+     * avg.push(5, 10);
+     * console.log(avg.value); // Output: 7.5 (average of 5, 10)
+     */
+    get value(): number;
+    /**
+     * Retrieves the count of numbers added so far.
+     *
+     * @returns {number} The count of numbers in the set.
+     *
+     * @example
+     * const avg = findMean();
+     * avg.push(10, 20);
+     * console.log(avg.count); // Output: 2
+     */
+    get count(): number;
+    /**
+     * Adds values to the set and updates the running mean.
+     *
+     * @param {...number} values - The values to add to the set.
+     * @returns {FindMean} The current instance of the FindMean class for chaining.
+     *
+     * @example
+     * const avg = findMean();
+     * avg.push(1, 2, 3);
+     * console.log(avg.value); // Output: 2 (average of 1, 2, 3)
+     * console.log(avg.count); // Output: 3
+     */
+    push(...values: number[]): FindMean;
+}
+/**
+ * Calculate the running mean (average) of a set of numbers.
+ *
+ * @param {number} [value] - An optional starting value for the mean calculation.
+ * @returns {FindMean} A new instance of FindMean class to calculate running mean.
+ *
+ * @example
+ * // Create a FindMean instance and add values to calculate the average
+ * const avg = findMean();
+ * avg.push(3, 3, 3.3);
+ * console.log(avg.value); // Output: 3.1
+ * console.log(avg.count); // Output: 3
+ *
+ * @group Numbers
+ */
+declare function findMean(value?: number): FindMean;
+
+interface FormatNumber {
+    thousands: string;
+    decimal: string;
+}
+/**
+ * Formats a number (or string representing a number) into a string with thousands separators and optional decimal points.
+ * The function supports customizing the formatting style using the `FormatNumber` object.
+ *
+ * @param {number | string} value - The number or string to format.
+ * If a string is passed, it is parsed to a number before formatting.
+ * @param {FormatNumber} [format=defaultFormat] - The format settings for thousands and decimal separators.
+ * By default, it uses the `{ thousands: ',', decimal: '.' }`.
+ *
+ * @returns {string} The formatted number string with appropriate thousands separators and decimal formatting.
+ *
+ * @example
+ * // Format a number with default thousands separator
+ * formatNumber(1500);
+ * // Returns: '1,500'
+ *
+ * @example
+ * // Format a number with a custom format (e.g., using a comma as the thousands separator)
+ * formatNumber(1500.75, { thousands: ' ', decimal: '.' });
+ * // Returns: '1 500.75'
+ *
+ * @group Numbers
+ */
+declare function formatNumber(value: number | string, format?: FormatNumber): string;
+
+interface FormatMoney extends FormatNumber {
+    symbol: string;
+    symbolBefore?: boolean;
+}
+/**
+ * Formats a given number (amount of money) as a currency string.
+ * This function supports both integer and floating-point representations of money
+ * and automatically applies the appropriate currency formatting for the specified currency code.
+ *
+ * @param {number} amount - The amount of money to format (in cents or as a floating-point value).
+ * @param {string | FormatMoney} formatOrCode - The currency format or the currency code (e.g., 'USD').
+ * If the format is passed as a string, the function will look up the format for that currency code.
+ * @param {boolean} [intMode=false] - When set to `true`, the amount is considered to be in integer form (i.e., cents).
+ * The value will be divided by 100 to convert it to a decimal format.
+ *
+ * @returns {string} The formatted money string, including the currency symbol and the properly formatted number.
+ *
+ * @example
+ * // Basic formatting with USD currency
+ * formatMoney(1500, 'USD');
+ * // Returns: '$1,500'
+ *
+ * @example
+ * // Formatting when the amount is in integer form (representing cents)
+ * formatMoney(1599, 'USD', true);
+ * // Returns: '$15.99'
+ *
+ * @group Numbers
+ */
+declare function formatMoney(amount: number, formatOrCode?: string | FormatMoney, intMode?: boolean): string;
+
+/**
+ * Returns a random integer between min (inclusive) and max (inclusive).
+ * The value is no lower than min (or the next integer greater than min
+ * if min isn't an integer) and no greater than max (or the next integer
+ * lower than max if max isn't an integer).
+ * Using Math.round() will give you a non-uniform distribution!
+ *
+ * @example
+ * getRandomInt(0, 100); // random int between 0 - 100
+ *
+ * @group Numbers
+ */
+declare function getRandomInt(min: number, max: number): number;
+
+/**
+ * Humanizes large numbers into a more readable format using suffixes like K, M, B, T (thousand, million, billion, trillion).
+ *
+ * @param {number | string} input - The number or string to humanize.
+ * If the input is a string, it will be parsed into a number.
+ * @param {number} [decimals=1] - The number of decimal places to display. Default is 1.
+ * @returns {string} A humanized string representation of the number.
+ *
+ * @example
+ * humanize(1000000);
+ * // Returns: '1M'
+ *
+ * @example
+ * humanize(1234567890);
+ * // Returns: '1.2B'
+ *
+ * @example
+ * humanize(9876543210, 2);
+ * // Returns: '9.88B'
+ *
+ * @example
+ * humanize(500);
+ * // Returns: '500'
+ *
+ * @example
+ * humanize('1000000');
+ * // Returns: '1M'
+ *
+ * @group Numbers
+ */
+declare function humanize(input: number | string, decimals?: number): string;
+
+/**
+ * Parses all numbers from a given string and returns them as an array of numbers.
+ * Supports dot decimals and ignores commas unless they appear as part of a number format.
+ * Returns an empty array when the input is invalid or no numbers are found.
+ *
+ * @param {unknown} input - The input value to parse numbers from.
+ * @returns {number[]} - An array of parsed numbers. Returns an empty array if no numbers are found.
+ *
+ * @example
+ * parseAllNumbers("The temperature is -23.5°C and humidity is 60%.");
+ * // Returns: [-23.5, 60]
+ *
+ * @example
+ * parseAllNumbers("No numbers here!");
+ * // Returns: []
+ *
+ * @example
+ * parseAllNumbers(42);
+ * // Returns: [42]
+ *
+ * @example
+ * parseAllNumbers("1,234 and 56.78 are numbers");
+ * // Returns: [1.234, 56.78]
+ *
+ * @example
+ * parseAllNumbers(["Invalid type"]);
+ * // Returns: []
+ *
+ * @group Numbers
+ */
+declare function parseAllNumbers(value: unknown): number[];
+
+/**
+ * Safely parses a percentage value and returns a number between 0 and 100.
+ * It accepts both string and numeric input, automatically handling the '%' sign if present.
+ * If the value is not a valid percentage, it returns 0.
+ *
+ * @param {unknown} value - The value to parse, which can be a string (e.g., '99%') or a number (e.g., 45).
+ * @returns {number} A parsed percentage value, constrained between 0 and 100.
+ * If the input is invalid or cannot be parsed, it returns 0.
+ *
+ * @example
+ * parsePercentage('99%');
+ * // Returns: 99
+ *
+ * @example
+ * parsePercentage('150%');
+ * // Returns: 100 (clamped to the maximum allowed value)
+ *
+ * @example
+ * parsePercentage('50.5%');
+ * // Returns: 50.5
+ *
+ * @example
+ * parsePercentage('abc');
+ * // Returns: 0 (invalid input)
+ *
+ * @example
+ * parsePercentage(80);
+ * // Returns: 80 (valid number input)
+ *
+ * @group Numbers
+ */
+declare function parsePercentage(value: unknown): number;
+
+/**
+ * Calculates the specified percentage of a given value.
+ * The result is the value multiplied by the percentage divided by 100.
+ * Optionally rounds the result to a specified number of decimal places.
+ *
+ * @param {number} value - The value from which the percentage will be calculated.
+ * @param {number} percent - The percentage to calculate from the value.
+ * @param {number} [digits] - Optional. The number of decimal places to round the result to. If not provided, the result will not be rounded.
+ * @returns {number} The calculated percentage of the value. If `digits` is provided, the result is rounded to the specified decimal places.
+ *
+ * @example
+ * percentOf(200, 20);
+ * // Returns: 40 (20% of 200)
+ *
+ * @example
+ * percentOf(200, 20, 2);
+ * // Returns: 40.00 (20% of 200 rounded to 2 decimal places)
+ *
+ * @example
+ * percentOf(150, 15);
+ * // Returns: 22.5 (15% of 150)
+ *
+ * @example
+ * percentOf(1000, 10, 1);
+ * // Returns: 100.0 (10% of 1000 rounded to 1 decimal place)
+ *
+ * @group Numbers
+ */
+declare function percentOf(value: number, percent: number, digits?: number): number;
+
+/**
+ * Rounds a given number to a specified number of decimal places.
+ * The rounding is done using a method that shifts the decimal point, rounds the number, and then shifts it back.
+ *
+ * @param {number} value - The number to be rounded.
+ * @param {number} [digits=2] - The number of decimal places to round to. Defaults to 2 if not provided.
+ * @returns {number} The rounded number with the specified number of decimal places.
+ *
+ * @example
+ * round2digits(3.3333333, 1);
+ * // Returns: 3.3
+ *
+ * @example
+ * round2digits(3.3333333, 2);
+ * // Returns: 3.33
+ *
+ * @example
+ * round2digits(3.3333333, 3);
+ * // Returns: 3.333
+ *
+ * @example
+ * round2digits(3.789, 0);
+ * // Returns: 4 (rounded to the nearest integer)
+ *
+ * @group Numbers
+ */
+declare function round2digits(value: number, digits?: number): number;
+
+/**
+ * Returns the number of seconds since the Unix epoch (January 1, 1970).
+ *
+ * This function accepts either a `Date` object or a timestamp in milliseconds (number).
+ * If no argument is provided, it defaults to the current timestamp in seconds.
+ *
+ * @param {Date | number} [fromValue=Date.now()] - The date or timestamp to convert.
+ * If not provided, the current date and time will be used.
+ *
+ * @returns {number} The number of seconds since the Unix epoch for the provided date or timestamp.
+ *
+ * @example
+ * // Using a Date object
+ * const date = new Date('2020-01-01T00:00:00Z');
+ * console.log(timestamp(date)); // Returns 1577836800 (seconds since Unix epoch)
+ *
+ * // Using a timestamp in milliseconds
+ * const timestampInMs = 1609459200000;
+ * console.log(timestamp(timestampInMs)); // Returns 1609459200 (seconds since Unix epoch)
+ *
+ * // Using the current time
+ * console.log(timestamp()); // Returns current seconds since Unix epoch
+ *
+ * @group Numbers
+ */
+declare function timestamp(fromValue?: Date | number): number;
+
+/**
+ * Converts a Unix timestamp (in seconds) to a `Date` object.
+ *
+ * This function accepts a timestamp in seconds (number) and returns a `Date` object
+ * corresponding to that timestamp. If an invalid number is passed (non-numeric or NaN),
+ * it returns `null`.
+ *
+ * @param {number} value - The Unix timestamp (in seconds) to convert into a `Date` object.
+ * @returns {Date | null} The `Date` object corresponding to the provided timestamp, or `null`
+ * if the value is not a valid number.
+ *
+ * @example
+ * const date = timestampToDate(1609459200);
+ * console.log(date); // Outputs: Thu Jan 01 2021 00:00:00 GMT+0000 (UTC)
+ *
+ * // Invalid input
+ * console.log(timestampToDate('invalid')); // Outputs: null
+ * console.log(timestampToDate(NaN)); // Outputs: null
+ * console.log(timestampToDate(null)); // Outputs: null
+ *
+ * @group Numbers
+ */
+declare function timestampToDate(value: number): Date | null;
+
+/**
+ * Removes properties with empty values from an object.
+ *
+ * This function iterates over the object's keys and deletes any property whose value
+ * is considered "empty" (e.g., `null`, `undefined`, `[]`, `{}`, `''`, `false`).
+ *
+ * ⚠️ **Mutates the original object**: The input object is directly modified, and properties
+ * are removed from it.
+ *
+ * @param {Record<string, any>} obj - The object to clean up, where empty fields will be removed.
+ * @returns {Record<string, any>} The cleaned object with empty fields removed.
+ *
+ * @example
+ * const user = { id: 1, name: 'Andrew', roles: [], address: null };
+ * cleanEmpty(user);
+ *
+ * console.log(user); // Outputs: { id: 1, name: 'Andrew' }
+ *
+ * @example
+ * const product = { name: 'Laptop', description: '', price: 1000, tags: [] };
+ * cleanEmpty(product);
+ *
+ * console.log(product); // Outputs: { name: 'Laptop', price: 1000 }
+ *
+ * @group Object
+ */
+declare function cleanEmpty(obj: Record<any, any>): Record<any, any>;
+
+/**
+ * Removes all properties from the given object, including symbol keys.
+ *
+ * This function deletes all enumerable properties, both string and symbol keys, from the
+ * input object. The object is directly mutated by this operation.
+ *
+ * ⚠️ **Mutates the original object**: The function modifies the input object in place.
+ *
+ * ⚠️ **Removes symbol keys**: Symbol-based keys are also deleted, unlike typical object
+ * iteration methods.
+ *
+ * @param {Record<string, any>} input - The object to clean up. After execution, it will be empty.
+ * @returns {void} This function does not return a value, as it mutates the input object directly.
+ *
+ * @example
+ * const user = { id: 1, name: 'Andrew', roles: [], [Symbol('unique')]: 'symbolValue' };
+ * cleanObject(user);
+ *
+ * console.log(user); // Outputs: {}
+ *
+ * @example
+ * const settings = { theme: 'dark', [Symbol('private')]: 'secret' };
+ * cleanObject(settings);
+ *
+ * console.log(settings); // Outputs: {}
+ *
+ * @group Object
+ */
+declare const cleanObject: (input: Record<string, any>) => void;
+
+/**
+ * Performs a deep merge of the source object into the destination object.
+ *
+ * This function recursively copies properties from the source object to the destination object.
+ * If a property is an object itself, it will recursively merge its properties. Otherwise,
+ * the value will be directly assigned to the destination object.
+ *
+ * ⚠️ **Mutates the destination object**: The destination object is modified in place.
+ *
+ * @param {object} dest - The target object that will be modified with properties from the source.
+ * @param {object} source - The source object whose properties will be copied to the destination.
+ * @returns {void} This function does not return a value, as it mutates the destination object.
+ *
+ * @example
+ * const user = {
+ *   id: 1,
+ *   name: 'Andrew',
+ *   data: { a: 1, b: 2 },
+ * };
+ *
+ * deepAssign(user, { data: { c: 3 } });
+ *
+ * console.log(user);
+ * // Outputs: '{ id: 1, name: 'Andrew', data: { a: 1, b: 2, c: 3 } }'
+ *
+ * @example
+ * const config = { theme: { dark: true }, version: '1.0' };
+ * const updates = { theme: { light: false }, version: '2.0' };
+ *
+ * deepAssign(config, updates);
+ *
+ * console.log(config);
+ * // Outputs: '{ theme: { dark: true, light: false }, version: '2.0' }'
+ *
+ * @group Object
+ */
+declare const deepAssign: (dest: object, source: object) => void;
+
+/**
+ * Recursively clones the provided value, creating a deep copy.
+ *
+ * This function performs a deep clone of the provided value. Any nested objects, arrays, or other complex types will be cloned recursively,
+ * ensuring that the original value and the cloned value are completely independent.
+ *
+ * @param {T} value - The value to recursively clone. Can be any type (object, array, primitive, etc.).
+ * @returns {T} Returns a new deeply cloned instance of the original value.
+ *
+ * @example
+ * const original = { name: 'Alice', details: { age: 25, country: 'Wonderland' } };
+ * const cloned = deepClone(original);
+ *
+ * cloned.details.age = 30;
+ * console.log(original.details.age); // 25
+ * console.log(cloned.details.age);   // 30
+ *
+ * @example
+ * const arr = [1, [2, 3], 4];
+ * const clonedArr = deepClone(arr);
+ * clonedArr[1][0] = 99;
+ * console.log(arr[1][0]); // 2
+ * console.log(clonedArr[1][0]); // 99
+ *
+ * @group Object
+ */
+declare const deepClone: <T>(value: T) => T;
+
+type WithCustomizer = (value: any, key: number | string | undefined) => any;
+type WithCustomizerFactory = () => WithCustomizer;
+type WithCustomizerValue = Readonly<Arrayable<WithCustomizer | WithCustomizerFactory>>;
+/**
+ * Recursively clones the provided value with a customizer function that allows for transformation of certain values during the cloning process.
+ *
+ * This function deep clones the value while providing a way to customize the cloning behavior of certain properties or elements.
+ * The `customizer` function will be called for each value being cloned, and if the customizer function returns a value other than `undefined`,
+ * the original value will be replaced with the returned value. This allows for specific modifications to parts of the structure being cloned.
+ *
+ * @param {T} value - The value to recursively clone. Can be any type (object, array, primitive, etc.).
+ * @param {WithCustomizerValue} customizer - A function to customize the cloning process. It receives the current value and key, and must return
+ *                                            either a modified value or `undefined` (to keep the original value).
+ *
+ * @returns {T} Returns a new deep clone of the original value, with customizations applied as per the `customizer` function.
+ *
+ * @example
+ * const original = { name: 'Alice', age: 30, details: { country: 'Wonderland', city: 'London' } };
+ *
+ * const customizer = (value, key) => {
+ *   if (key === 'city') return 'Paris';  // Customizing the 'city' field to 'Paris'.
+ * };
+ *
+ * const cloned = deepCloneWith(original, customizer);
+ * console.log(cloned.details.city);  // 'Paris'
+ * console.log(original.details.city);  // 'London' (original is unchanged)
+ *
+ * @example
+ * const arr = [1, [2, 3], 4];
+ *
+ * const customizer = (value) => {
+ *   if (Array.isArray(value)) return value.map(item => item * 2);  // Doubling the numbers inside arrays.
+ * };
+ *
+ * const clonedArr = deepCloneWith(arr, customizer);
+ * console.log(clonedArr); // [1, [4, 6], 4]
+ * console.log(arr); // [1, [2, 3], 4] (original is unchanged)
+ *
+ * @group Object
+ */
+declare function deepCloneWith<T>(value: T, customizer: WithCustomizerValue): T;
+declare function createDeepCloneWith(customizer: WithCustomizerValue): <T>(value: T) => T;
+declare function isCustomizerFactory(value: unknown): value is WithCustomizerFactory;
+declare function createCustomizer(fn: WithCustomizer): WithCustomizer;
+declare function createCustomizerFactory(fn: (...args: any[]) => WithCustomizer): WithCustomizerFactory;
+declare function createSecureCustomizer(properties: string[]): WithCustomizerFactory;
+
+/**
+ * Recursively assigns default properties.
+ * @param object The destination object.
+ * @param sources The source objects.
+ * @return Returns object.
+ *
+ * @example
+ * const obj = { name: 'Alice', age: 30 };
+ * const defaults = { name: 'Bob', age: 25, country: 'Wonderland' };
+ *
+ * deepDefaults(obj, defaults);
+ * console.log(obj);
+ * // Output: { name: 'Alice', age: 30, country: 'Wonderland' }
+ * // The 'name' and 'age' properties are not overwritten since they already exist.
+ *
+ * @example
+ * const obj = { user: { name: 'Alice' } };
+ * const defaults = { user: { age: 25 } };
+ *
+ * deepDefaults(obj, defaults);
+ * console.log(obj);
+ * // Output: { user: { name: 'Alice', age: 25 } }
+ * // The 'age' property is added to 'user', while 'name' remains unchanged.
+ *
+ * @group Object
+ */
+declare const deepDefaults: (object: any, ...sources: any[]) => any;
+
+/**
+ * Recursively freezes an object or array, making it immutable at all levels.
+ *
+ * This function is similar to `Object.freeze()`, but instead of freezing only the top-level
+ * properties of an object, it recursively freezes every nested object or array, ensuring
+ * that no properties or elements can be modified at any depth.
+ *
+ * **Important**:
+ * - Once frozen, attempting to modify any property or element of the object will result in an error in strict mode.
+ * - If a property of an object or an element of an array is itself an object, it will also be frozen.
+ *
+ * @param {T} value - The object or array to freeze deeply.
+ * @returns {T} The frozen object or array, which is also deeply immutable.
+ *
+ * @example
+ * const config = deepFreeze({
+ *   db: { uri: '' },
+ * });
+ *
+ * config.db.uri = 'test'; // Error: Cannot assign to read-only property 'uri' of object
+ *
+ * @example
+ * const arr = deepFreeze([ { name: 'Alice' }, { name: 'Bob' } ]);
+ * arr[0].name = 'Charlie'; // Error: Cannot assign to read-only property 'name' of object
+ *
+ * @group Object
+ */
+declare function deepFreeze<T extends object | unknown[]>(value: T): T;
+
+/**
+ * Define not enumerable property in object.
+ *
+ * @example
+ * const USER_SYM = Symbol();
+ * const user = { id: 1, name: 'Andrew' };
+ *
+ * // define hidden marker
+ * def(user, USER_SYM, true);
+ *
+ * console.log(user[USER_SYM] === true); // true
+ *
+ * @group Object
+ */
+declare const def: (obj: object, key: string | symbol, value: any, writable?: boolean) => void;
+
+/**
+ * @example
+ * const PERMISSIONS = {
+ *   USER_CREATE: 1 << 0,
+ *   USER_UPDATE: 1 << 1,
+ *   USER_DELETE: 1 << 2,
+ *   USER_LIST: 1 << 4,
+ * } as const;
+ *
+ * const scope = PERMISSIONS.USER_CREATE | PERMISSIONS.USER_LIST;
+ *
+ * // { USER_CREATE: true, USER_UPDATE: false, USER_DELETE: false, USER_LIST: true }
+ * const flags = flagsToMap(scope, PERMISSIONS);
+ */
+declare function flagsToMap(value: number, bitmaskMap: Record<string, number>): Record<string, boolean>;
+declare function flagsToMap(value: bigint, bitmaskMap: Record<string, bigint>): Record<string, boolean>;
+
+interface FlattenOptions {
+    /**
+     * Character to separate the flattened keys
+     */
+    separator?: string;
+    /**
+     * Prefix to add to the flattened keys
+     */
+    initialPrefix?: string;
+    /**
+     * Whether to include arrays in the flattened result
+     */
+    withArrays?: boolean;
+    /**
+     * Custom function to check if a value is an object
+     */
+    isObjectCompare?: (value: unknown) => boolean;
+}
+/**
+ * Flattens a nested object into a single-level object, converting nested properties
+ * into key-value pairs with keys representing the property path.
+ *
+ * By default, nested objects are flattened with an underscore (`_`) separator.
+ * Arrays can also be flattened into indexed keys. A custom function can be provided
+ * to determine if a value should be treated as an object.
+ *
+ * **Important**:
+ * - Nested objects are flattened with keys joined by the `separator` (default: `_`).
+ * - Arrays are flattened by their indices (e.g., `array[0]` becomes `array_0`).
+ * - A custom `isObjectCompare` function can be provided to determine whether a value
+ *   should be treated as an object.
+ *
+ * @param {Record<string, unknown>} obj - The object to flatten.
+ * @param {FlattenOptions} options - Optional configuration for flattening behavior.
+ * @param {string} [options.separator='_'] - Separator for flattening object keys (default is '_').
+ * @param {string} [options.initialPrefix=''] - Prefix to prepend to flattened keys (default is '').
+ * @param {boolean} [options.withArrays=true] - Whether to include arrays in the flattened result (default is true).
+ * @param {(value: unknown) => boolean} [options.isObjectCompare=isObject] - Custom function to check if a value is an object.
+ * @returns {Record<string, unknown>} - The flattened object.
+ *
+ * @example
+ * flatten({
+ *   name: 'Andrew',
+ *   config: {
+ *     canReadPost: true,
+ *     canUpdatePost: true,
+ *   }
+ * });
+ * // Result:
+ * // {
+ * //   'name': 'Andrew',
+ * //   'config_canReadPost': true,
+ * //   'config_canUpdatePost': true,
+ * // }
+ *
+ *  @example
+ * flatten(
+ *   { user: { name: 'Jane', profile: { age: 30 } } },
+ *   { separator: '-', initialPrefix: 'root-' }
+ * );
+ * // Returns:
+ * // { 'root-user-name': 'Jane', 'root-user-profile-age': 30 }
+ *
+ * @group Object
+ */
+declare function flatten(obj: Record<string, unknown>, { separator, initialPrefix, withArrays, isObjectCompare, }?: FlattenOptions): Record<string, unknown>;
+
+/**
+ * Get object property by dot notation
+ *
+ * @example
+ * const user = { id: 1, data: { roles: ['admin'] } };
+ * const roles = get(user, 'data.roles');
+ *
+ * console.log(roles) // ['admin']
+ *
+ * @group Object
+ */
+declare const get: {
+    <TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
+    <TObject extends object, TKey extends keyof TObject>(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined;
+    <TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude<TObject[TKey], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable<TObject[TKey1]>[TKey2] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude<NonNullable<TObject[TKey1]>[TKey2], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3], undefined> | TDefault;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4]): NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4] | undefined;
+    <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): Exclude<NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4], undefined> | TDefault;
+    <T>(object: lodash.NumericDictionary<T>, path: number): T;
+    <T>(object: lodash.NumericDictionary<T> | null | undefined, path: number): T | undefined;
+    <T, TDefault>(object: lodash.NumericDictionary<T> | null | undefined, path: number, defaultValue: TDefault): T | TDefault;
+    <TDefault>(object: null | undefined, path: lodash.PropertyPath, defaultValue: TDefault): TDefault;
+    (object: null | undefined, path: lodash.PropertyPath): undefined;
+    <TObject, TPath extends string>(data: TObject, path: TPath): string extends TPath ? any : lodash.GetFieldType<TObject, TPath>;
+    <TObject, TPath extends string, TDefault = lodash.GetFieldType<TObject, TPath, "Path">>(data: TObject, path: TPath, defaultValue: TDefault): Exclude<lodash.GetFieldType<TObject, TPath>, null | undefined> | TDefault;
+    (object: any, path: lodash.PropertyPath, defaultValue?: any): any;
+};
+
+/**
+ * Returns true when provided keys exists in target object
+ *
+ * @example
+ * const user = { id: 1, name: 'Andrew' };
+ *
+ * has(user, ['roles']); // false
+ * has(user, ['roles', 'name']); // false
+ * has(user, ['name']); // true
+ *
+ * @group Object
+ */
+declare function has<T extends PropertyKey>(value: any, keys: T[]): value is {
+    [K in T]: any;
+};
+
+/**
+ * Check if object has own property
+ *
+ * @group Object
+ */
+declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;
+
+/**
+ * Creates a new object with specified keys omitted.
+ *
+ * This function takes an object and an array of keys, and returns a new object that
+ * excludes the properties corresponding to the specified keys.
+ *
+ * @template T - The type of object.
+ * @template K - The type of keys in object.
+ * @param {T} obj - The object to omit keys from.
+ * @param {K[]} keys - An array of keys to be omitted from the object.
+ * @returns {Omit<T, K>} A new object with the specified keys omitted.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = omit(obj, ['b', 'c']);
+ * // result will be { a: 1 }
+ *
+ * @group Object
+ */
+declare function omit<T extends Record<string, any>, U extends keyof T>(obj: T, excludes: Readonly<Array<U> | Set<U> | Array<string> | Set<string>>): Omit<T, U>;
+
+/**
+ * Pick object keys with excluding prefix keys
+ *
+ * @example
+ * const record = {
+ *   id: 1,
+ *   canRead: true,
+ *   canWrite: true,
+ * };
+ *
+ * omitPrefixed(record, 'can'); // { id: 1 }
+ *
+ * @group Object
+ */
+declare function omitPrefixed(obj: Record<string, unknown>, prefix: string): Record<string, unknown>;
+
+/**
+ * Creates a new object composed of the picked object properties.
+ *
+ * This function takes an object and an array of keys, and returns a new object that
+ * includes only the properties corresponding to the specified keys.
+ *
+ * @template T - The type of object.
+ * @template K - The type of keys in object.
+ * @param {T} obj - The object to pick keys from.
+ * @param {K[]} keys - An array of keys to be picked from the object.
+ * @returns {Pick<T, K>} A new object with the specified keys picked.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = pick(obj, ['a', 'c']);
+ * // result will be { a: 1, c: 3 }
+ *
+ * @group Object
+ */
+declare function pick<T extends Record<string, any>, U extends keyof T>(obj: T | null | undefined, keys: Readonly<Array<U> | Set<U> | Array<string> | Set<string>>): Pick<T, U>;
+
+interface PrefixedValuesOptions {
+    /**
+     * Key prefix
+     */
+    prefix: string;
+    /**
+     * Remove prefix from resulted object
+     * @default false
+     */
+    prefixTrim?: boolean;
+}
+/**
+ * Pick prefixed keys in target object
+ *
+ * @example
+ * const record = {
+ *   id: 1,
+ *   canRead: true,
+ *   canWrite: true,
+ * };
+ *
+ *  // { canRead: true, canWrite: true }
+ * pickPrefixed(record, 'can');
+ *
+ * // { Read: true, Write: true }
+ * pickPrefixed(record, { prefix: 'can', prefixTrim: true });
+ *
+ * @group Object
+ */
+declare function pickPrefixed(obj: object, options: PrefixedValuesOptions | string): {};
+
+/**
+ * Same as `get` but for setting property by dot notation.
+ *
+ * @group Object
+ */
+declare const set: {
+    <T extends object>(object: T, path: lodash.PropertyPath, value: any): T;
+    <TResult>(object: object, path: lodash.PropertyPath, value: any): TResult;
+};
+
+/**
+ * Converts object into Map
+ *
+ * @example
+ * const map = toMap({ user1: 'Andrew', user2: 'John' });
+ *
+ * map.get('user2'); // John
+ *
+ * @group Object
+ */
+declare const toMap: <T extends object>(obj: T) => Map<keyof T, T[keyof T]>;
+
+/**
+ * Converts a flattened object back into a nested structure.
+ *
+ * Takes an object with dot-separated keys and converts it into a nested object,
+ * where each dot-separated part of the key represents a deeper level in the object.
+ *
+ * @param {Object} obj - The object to unflatten.
+ * @param {string} [separator='_'] - The separator used to split the keys into their nested form. Defaults to '_'.
+ * @returns {Object} The unflattened object, with nested keys restored to their original structure.
+ *
+ * @example
+ * const obj = {
+ *   'name': 'Andrew',
+ *   'config_canReadPost': true,
+ *   'config_canUpdatePost': true,
+ * };
+ *
+ * unflatten(obj);
+ * // Returns:
+ * // {
+ * //   name: 'Andrew',
+ * //   config: {
+ * //     canReadPost: true,
+ * //     canUpdatePost: true
+ * //   },
+ * // }
+ *
+ * @example
+ * const flattenedObj = {
+ *   'user.firstName': 'John',
+ *   'user.lastName': 'Doe',
+ *   'address.city': 'New York'
+ * };
+ *
+ * unflatten(flattenedObj, '.');
+ * // Returns:
+ * // {
+ * //   user: {
+ * //     firstName: 'John',
+ * //     lastName: 'Doe'
+ * //   },
+ * //   address: {
+ * //     city: 'New York'
+ * //   }
+ * // }
+ *
+ * @group Object
+ */
+declare function unflatten(obj: object, separator?: string): {};
+
+/**
+ * Same as `set` but unset by dot notation
+ * @group Object
+ */
+declare const unset: (object: any, path: lodash.PropertyPath) => boolean;
+
+/**
+ * Asynchronously filters an array using an async predicate function.
+ *
+ * This function processes an array using an async function as the predicate,
+ * allowing you to avoid blocking the event loop while iterating over large arrays.
+ * It ensures that the iteration happens asynchronously with minimal impact on the event loop,
+ * making it useful for processing large datasets or performing async operations on each element.
+ *
+ * @param array - The array to be filtered.
+ * @param predicate - The async predicate function.
+ *  It takes three arguments: the current value, the index of the current value, and the full array.
+ *  It should return a boolean value or a promise that resolves to a boolean indicating whether the value should be kept in the result array.
+ *
+ * @returns {Promise<T[]>} A promise that resolves to a new array containing the elements that satisfy the predicate.
+ *
+ * @example
+ * const users = Array.from({ length: 100000 }).map((_, idx) => ({
+ *   id: idx,
+ *   name: 'User: ' + (idx + 1)
+ * }));
+ *
+ * async function first100Users() {
+ *   return await asyncFilter(users, (user) => user.id < 100);
+ * }
+ *
+ * Promise.all([
+ *   first100Users(),
+ *   otherUsefulTask(),
+ * ]).then(console.log);
+ *
+ * @group Promise
+ */
+declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean): Promise<T[]>;
+
+/**
+ * Asynchronously finds the first element in an array that satisfies the provided async predicate.
+ *
+ * This function iterates through an array and applies an asynchronous predicate to each element.
+ * If the predicate resolves to a truthy value for any element, that element is returned immediately.
+ * The function is designed to prevent blocking the event loop during iteration, making it suitable
+ * for processing large arrays without impacting performance.
+ *
+ * @param array - The array to search through.
+ * @param callbackfn - The asynchronous predicate function.
+ *  It takes three arguments: the current value, the index of the current value, and the full array.
+ *  The predicate function should return a boolean or a promise that resolves to a boolean indicating
+ *  whether the current value satisfies the condition.
+ *
+ * @returns {Promise<T | undefined>} A promise that resolves to the first element that satisfies the predicate, or `undefined` if no element matches.
+ *
+ * @example
+ * // Example of using asyncFind to find users by ID asynchronously
+ * const users = Array.from({ length: 100000 }).map((_, idx) => ({
+ *   id: idx,
+ *   name: 'User: ' + (idx + 1)
+ * }));
+ *
+ * async function findById(userId: number) {
+ *   return await asyncFind(users, (user) => user.id === userId);
+ * }
+ *
+ * Promise.all([
+ *   findById(5000),
+ *   findById(6000),
+ * ]).then(console.log);
+ *
+ * @group Promise
+ */
+declare function asyncFind<T>(array: T[], callbackfn: (value: T, index: number, array: T[]) => Promise<unknown> | unknown): Promise<T | undefined>;
+
+/**
+ * Asynchronously iterates over an array, executing the provided callback for each element with support for parallel processing.
+ *
+ * This function is similar to `Array.prototype.forEach()`, but it allows asynchronous operations in parallel for each array element.
+ * It also prevents blocking the event loop while iterating through large arrays, improving performance for heavy tasks.
+ * The function processes items in batches to manage concurrency and can be configured to process multiple items at the same time.
+ *
+ * **Note**: The callback function can return either a promise or a value. If it returns a promise, `asyncForEach` will wait for it to resolve before moving to the next iteration.
+ *
+ * @param array - The array to iterate over.
+ * @param callbackfn - The async callback function to execute for each element.
+ *  This function takes three parameters:
+ *   - `value`: The current element of the array.
+ *   - `index`: The index of the current element in the array.
+ *   - `array`: The array that is being iterated over.
+ *  The function should either return a `void` or a `Promise` that resolves when the async operation is done.
+ *
+ * @param {Object} [options] - Optional settings to control the concurrency of the operation.
+ * @param {number} [options.concurrency=1] - The number of items to process in parallel. Defaults to 1 (sequential processing).
+ *
+ * @returns {Promise<void>} A promise that resolves when all elements have been processed.
+ *
+ * @example
+ * async function task(taskName: string) {
+ *   const largeArray = Array.from({ length: 100000 }).map((_, idx) => idx);
+ *
+ *   await asyncForEach(largeArray, (value) => {
+ *     if (value % 100 === 0) {
+ *       console.log(taskName, 'handle:', value);
+ *     }
+ *   });
+ * }
+ *
+ * Promise.all([
+ *   task('task 1'),
+ *   task('task 2'),
+ * ]);
+ *
+ * @group Promise
+ */
+declare function asyncForEach<T>(array: T[], callbackfn: (value: T, index: number, array: Array<T>) => Promise<void> | void, { concurrency }?: {
+    concurrency?: number | undefined;
+}): Promise<void>;
+
+/**
+ * An asynchronous queue implementation that can be iterated using an async iterator.
+ * It allows items to be added (`put`) and consumed asynchronously, with the ability to signal when the queue is closed.
+ * This class supports async iteration, enabling users to process items as they become available, and provides an end signal once the queue is closed.
+ *
+ * @example
+ * const textStream = new AsyncIterableQueue<string>();
+ *
+ * const readTimer = setInterval(() => {
+ *   textStream.put('Hey ' + Math.random());
+ * }, 100);
+ *
+ * setTimeout(() => {
+ *   textStream.close();
+ *   clearInterval(readTimer);
+ * });
+ *
+ * for await (const text of textStream) {
+ *   console.log('text part', { text });
+ * }
+ *
+ * @group Promise
+ */
+declare class AsyncIterableQueue<T> implements AsyncIterable<T> {
+    private _queue;
+    private _closed;
+    private static readonly QUEUE_END_MARKER;
+    constructor();
+    get closed(): boolean;
+    put(item: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+/**
+ * Asynchronously maps over an array, applying the provided callback function to each element,
+ * with support for parallel processing of array elements.
+ *
+ * This function is similar to `arr.map()`, but allows asynchronous operations
+ * for each array element, helping to avoid blocking the event loop when processing large arrays.
+ * It processes the array elements in batches, providing support for concurrency, meaning multiple
+ * elements can be processed in parallel.
+ *
+ * **Note**: The callback function can return either a value or a `Promise`. If a `Promise` is returned,
+ * `asyncMap` will wait for it to resolve before moving on to the next iteration.
+ *
+ * @param array - The array to iterate over.
+ * @param callbackfn - The async callback function to apply to each element.
+ *  This function takes three parameters:
+ *   - `value`: The current element of the array.
+ *   - `index`: The index of the current element in the array.
+ *   - `array`: The array being processed.
+ *  The callback should return either a transformed value (`U`) or a `Promise<U>`.
+ *
+ * @param {Object} [options] - Optional configuration for controlling concurrency.
+ * @param {number} [options.concurrency=1] - The number of items to process concurrently. Default is 1 (sequential processing).
+ *
+ * @returns {Promise<U[]>} A promise that resolves to an array of transformed elements.
+ *
+ * @example
+ * const users = Array.from({ length: 100 }).map((_, idx) => ({
+ *   id: idx,
+ *   name: 'User: ' + (idx + 1)
+ * }));
+ *
+ * async function withUserClients() {
+ *   return await asyncMap(users, async (user) => {
+ *     const clients = await db.clients.find({ user: user.id });
+ *
+ *     return { ...user, clients };
+ *   }, { concurrency: 10 });
+ * }
+ *
+ * Promise.all([
+ *   withUserClients(),
+ *   otherUsefulTask(),
+ * ]).then(console.log);
+ *
+ * @group Promise
+ */
+declare function asyncMap<T, U>(array: T[], callbackfn: (value: T, index: number, array: Array<T>) => Promise<U> | U, { concurrency }?: {
+    concurrency?: number | undefined;
+}): Promise<Array<U>>;
+
+/**
+ * A custom promise that supports cancellation.
+ * Allows users to cancel the promise operation before it completes, avoiding unnecessary execution.
+ * This class provides a mechanism to perform asynchronous tasks that can be stopped midway by calling the `cancel` method.
+ *
+ * @example
+ * const task = new CancellablePromise<void>(async (resolve, reject, onCancel) => {
+ *   let cancelled = false;
+ *   onCancel(() => {
+ *     cancelled = true;  // Define the cancellation logic here
+ *   });
+ *
+ *   while (!cancelled) {
+ *     await delay(1000);  // Simulate async work
+ *     console.log('handling task...');
+ *   }
+ * });
+ *
+ * // Cancel the task after 5 seconds
+ * setTimeout(() => task.cancel(), 5000);
+ *
+ * await task;  // This will be cancelled before it completes
+ * console.log('Task completed or cancelled');
+ *
+ * @group Promise
+ */
+declare class CancellablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: (cancelFn: () => void) => void) => void);
+    get [Symbol.toStringTag](): string;
+    get isCancelled(): boolean;
+    get error(): Error | null;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | Promise<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | Promise<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    static from<T>(promise: Promise<T>): CancellablePromise<T>;
+}
+
+interface Defer<T = unknown> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (value: any) => void;
+}
+/**
+ * Old known defer :)
+ *
+ * @example
+ * function loadModule() {
+ *   const q = defer<void>();
+ *
+ *   setTimeout(() => q.resolve(), 5000);
+ *
+ *   return q.promise;
+ * }
+ *
+ * await loadModule();
+ *
+ * @group Promise
+ */
+declare function defer<T = void>(): Defer<T>;
+
+/**
+ * Returns a promise that resolves after the provided delay.
+ *
+ * If the delay is specified as `'tick'`, the promise resolves after the next event loop tick.
+ *
+ * If a numeric delay is provided, the promise resolves after the specified time in milliseconds.
+ *
+ * This is useful for introducing delays in asynchronous code, such as for throttling or rate-limiting,
+ * or simply pausing execution between iterations.
+ *
+ * @param amount - The delay duration in milliseconds, or `'tick'` for a resolution after the next event loop tick.
+ * @returns A promise that resolves after the specified delay.
+ *
+ * @example
+ * let seconds = 0;
+ *
+ * // This will print numbers 1, 2, 3... every second
+ * while (true) {
+ *   await delay(1000);
+ *   console.log(++seconds);
+ * }
+ *
+ * @example
+ * // This will wait until the next event loop tick before resolving
+ * await delay('tick');
+ *
+ * @group Promise
+ */
+declare function delay(amount?: 'tick' | number): Promise<void>;
+
+/**
+ * Executes the provided callback as soon as the event loop is idle.
+ * This function allows you to run tasks at the earliest available opportunity
+ * without blocking the main execution flow, making it ideal for tasks that can
+ * be deferred until the browser is idle or the process is idle.
+ *
+ * It uses `requestIdleCallback` if available, otherwise it falls back to
+ * `requestAnimationFrame`, `process.nextTick`, or `setTimeout` depending on the environment.
+ *
+ * @example
+ * fastIdle(() => {
+ *   console.log('1');
+ * });
+ *
+ * console.log('2');
+ *
+ * // Output:
+ * // 2
+ * // 1
+ *
+ * @param callback - The callback function to be executed when the event loop is idle.
+ *
+ * @group Promise
+ */
+declare function fastIdle(callback: Fn): void;
+/**
+ * Same as `fastIdle` but promisified
+ *
+ * @example
+ * fastIdlePromise().then(() => {
+ *   console.log('1');
+ * });
+ *
+ * console.log('2');
+ *
+ * // 2
+ * // 1
+ *
+ * @group Promise
+ */
+declare function fastIdlePromise(): Promise<void>;
+
+type NoneToVoidFunction = () => void;
+/**
+ * Stacks callbacks for `requestAnimationFrame` into a single execution call.
+ *
+ * This function allows multiple `fastRaf` calls to be batched into a single animation frame callback.
+ * The callbacks are executed in the same frame, one after the other. Additionally, if `withTimeoutFallback` is true,
+ * the callbacks will be executed after a fallback timeout if `requestAnimationFrame` is not available.
+ * If called from within another RAF callback, the execution might be immediate.
+ *
+ * @example
+ * // Callbacks will be executed in the same `requestAnimationFrame` cycle
+ * fastRaf(() => console.log(1));
+ * fastRaf(() => console.log(2));
+ *
+ * // Output:
+ * // 1
+ * // 2
+ *
+ * @param callback The callback function to be executed in the next `requestAnimationFrame`.
+ * @param [withTimeoutFallback=false] Optional flag to execute callbacks after a fallback timeout if `requestAnimationFrame` is not available.
+ * @group Promise
+ */
+declare function fastRaf(callback: NoneToVoidFunction, withTimeoutFallback?: boolean): void;
+declare function rafPromise(): Promise<void>;
+
+/**
+ * Creates a cooldown function that resolves after a specified number of executions (`amount`).
+ * The cooldown can either occur on the `next` tick or after a specified delay.
+ *
+ * This is useful for controlling the rate of asynchronous operations, allowing you to pause
+ * for a specified amount of time after a certain number of iterations in a loop.
+ *
+ * @example
+ * // Create a cooldown function that waits 1 tick for every 10th execution
+ * const cooldown = nextTickIteration(10);
+ *
+ * for (const item of array) {
+ *     await cooldown(); // Wait 1 tick for every 10th call
+ *     // Perform some async operation here
+ * }
+ *
+ * @example
+ * // Create a cooldown function with a 100ms delay after every 5 executions
+ * const cooldownWithDelay = nextTickIteration(5, 100);
+ * for (const item of array) {
+ *     await cooldownWithDelay(); // Wait 100ms after every 5th call
+ *     // Perform some async operation here
+ * }
+ *
+ * @param amount The number of executions after which the cooldown should occur.
+ * @param delay The delay type or amount. If 'tick', it uses the next idle tick.
+ *              If a number is provided, it specifies a delay in milliseconds.
+ * @returns A function that, when called, returns a promise resolving after the specified cooldown period.
+ *
+ * @group Promise
+ */
+declare function nextTickIteration(amount: number, delay?: number | 'tick'): () => Promise<void>;
+
+/**
+ * A basic queue implementation with a limit and event-based synchronization.
+ *
+ * This class allows you to put items into a queue and retrieve them asynchronously.
+ * If the queue exceeds a specified limit, the `put` operation will wait until an item is retrieved,
+ * and similarly, the `get` operation will wait if there are no items available in the queue.
+ *
+ * @example
+ * // Create a queue with a limit of 10 items
+ * const sendQueue = new Queue<any>(10);
+ *
+ * // Add items to the queue
+ * sendQueue.put({ url: '/api/message.send', params: { text: 'hello' } });
+ * sendQueue.put({ url: '/api/message.send', params: { text: 'how are you?' } });
+ *
+ * // Retrieve and process items from the queue asynchronously
+ * while (true) {
+ *   const req = await sendQueue.get();
+ *   http.post(req.url, { body: req.params });
+ * }
+ *
+ * @param limit - Optional maximum number of items the queue can hold. If not provided, the queue has no limit.
+ *
+ * @group Promise
+ */
+declare class Queue<T> {
+    #private;
+    items: T[];
+    constructor(limit?: number);
+    get(): Promise<T>;
+    put(item: T): Promise<void>;
+}
+
+type SimpleEventMap<T> = Record<keyof T, any[]> | SimpleDefaultEventMap;
+type SimpleDefaultEventMap = [never];
+type Key<K, T> = T extends SimpleDefaultEventMap ? string | symbol : K | keyof T;
+type Listener<K, T, F> = T extends SimpleDefaultEventMap ? F : K extends keyof T ? T[K] extends unknown[] ? (...args: T[K]) => void : never : never;
+type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
+type Args<K, T> = T extends SimpleDefaultEventMap ? [...args: any[]] : K extends keyof T ? T[K] : never;
+/**
+ * Simplified version on nodejs `EventEmitter` but platform agnostic
+ *
+ * @example
+ * const emitter = new SimpleEventEmitter();
+ *
+ * emitter.on('message', (data) => {
+ *   console.log('msg', data)
+ * });
+ *
+ * emitter.once('message', (data) => {
+ *   console.log('once msg', data)
+ * });
+ *
+ * emitter.emit('message', { text: 'Hello' });
+ * emitter.emit('message', { text: 'Hello 2' });
+ *
+ * @group Promise
+ */
+declare class SimpleEventEmitter<T extends SimpleEventMap<T> = SimpleDefaultEventMap> {
+    #private;
+    constructor();
+    static once(emitter: SimpleEventEmitter, eventName: string | symbol): Promise<any[]>;
+    emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): boolean;
+    on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+    once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+    off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+    removeAllListeners(eventName?: Key<unknown, T>): this;
+}
+
+/**
+ * Throws an error if the provided promise or callback is not resolved within the specified timeout period.
+ *
+ * This function can be used to ensure that an asynchronous operation does not take too long to complete.
+ * If the operation exceeds the specified time limit, the provided `timeoutError` is thrown.
+ *
+ * @example
+ * // Example usage: Throw an error if no response is received within 1 second
+ * await timeout(
+ *   1000, // Timeout duration in milliseconds
+ *   (signal) => {
+ *     const account = await http.get('/api/users/me');
+ *
+ *     if (signal.aborted) return; // If the timeout occurs, abort the operation
+ *
+ *     const statistics = await http.get('/api/users/me/statistics');
+ *
+ *     return { ...account, statistics };
+ *   },
+ *   new Error('Request account timeout') // Custom error to throw on timeout
+ * );
+ *
+ * @param ms - The maximum time (in milliseconds) to wait for the promise or callback to resolve.
+ * @param promiseOrCallback - The asynchronous operation to execute. This can either be:
+ *   - A `Promise` that will be awaited until completion, or
+ *   - A function that takes an `AbortSignal` and returns a `Promise` or a value.
+ * @param timeoutError - The error that will be thrown if the timeout is reached before the promise or callback resolves.
+ *   (Defaults to `Error('Timeout')` if not provided).
+ * @returns A `Promise` that resolves with the result of the provided `promiseOrCallback`, or rejects with the `timeoutError` if the timeout occurs.
+ *
+ * @throws {Error} - Throws the `timeoutError` if the operation exceeds the specified timeout.
+ *
+ * @group Promise
+ */
+declare function timeout<T = any>(ms: number, promiseOrCallback: Promise<T> | ((abortSignal: AbortSignal) => Awaitable<T>), timeoutError?: any): Promise<T>;
+
+type TypeOf = keyof TypeOfMap;
+type TypeOfMap = {
+    null: null;
+    undefined: undefined;
+    object: Record<PropertyKey, any>;
+    string: string;
+    number: number;
+    function: AnyFunction;
+    bigint: bigint;
+    boolean: boolean;
+    symbol: symbol;
+    date: Date;
+    array: any[];
+    map: Map<any, any>;
+    weakmap: WeakMap<WeakKey, any>;
+    set: Set<any>;
+    weakset: WeakSet<WeakKey>;
+    unknown: unknown;
+};
+/**
+ * Typeof that you deserve
+ * @group Utility Functions
+ */
+declare function typeOf(value: unknown): TypeOf;
+
+type StringifyOptions = {
+    /**
+     * Exclude empty values, checking by `isEmpty`
+     * @default true
+     */
+    excludeEmpty?: boolean;
+    /**
+     * Exclude values when equals with defaults
+     */
+    excludeDefaults?: Record<string, any>;
+};
+/**
+ * Simple query stringy interface that supports encoding/decoding of `Array`, `Set`, `Map`, `Object`, `BigInt`
+ *
+ * @example
+ * // encode
+ * qs.stringify({ page: 1, limit: 10 }); // 'page=1&limit=10'
+ *
+ * // decode
+ * const defaults = { page: 1, limit: 10 };
+ * const params = qs.parse('page=5&limit=abc', defaults); // { page: 5, limit: 10 }
+ *
+ * @group Utility Functions
+ */
+declare const qs: {
+    toParams: typeof toParams;
+    stringify: typeof stringify;
+    stringifyValue: typeof stringifyValue;
+    parse: typeof parse;
+    parseValue: typeof parseValue;
+    merge: typeof merge;
+};
+/**
+ * Merge first level values
+ */
+declare function merge(...values: Record<string, any>[]): Record<string, any>;
+/**
+ * Simple function to transform object into query string (not standards)
+ */
+declare function stringify(obj: Record<string, any>, options?: StringifyOptions): string;
+/**
+ * Prepare search params object
+ */
+declare function toParams(obj: Record<string, any>, options?: StringifyOptions): Record<string, string>;
+/**
+ * Parse query string as is without type casting
+ */
+declare function parse(value: string): Record<string, string>;
+/**
+ * Parse query string and use default object as type cast schema
+ */
+declare function parse<T extends Record<string, any>>(value: string, defaults: Partial<T>): T;
+/**
+ * Parse query params and use default object as type cast schema
+ */
+declare function parse<T extends Record<string, any>>(value: Record<string, any>, defaults: T): Partial<T>;
+/**
+ * Stringify value to use as query parameter
+ */
+declare function stringifyValue(value: unknown): string;
+/**
+ * Parse string query value as a type
+ */
+declare function parseValue<T extends TypeOf>(value: any, asType: T): TypeOfMap[T] | undefined;
+
+type RetryOnErrorConfig = {
+    /**
+     * The function to execute before retry attempt; Allows to update parameters for the main function by returning then in an array
+     */
+    beforeRetryCallback?: (attempt: number, lastAttempt: boolean) => Promise<unknown[] | void>;
+    /**
+     * Error validation function. If returns true, the main callback's considered ready to be executed again
+     */
+    shouldRetryBasedOnError: (error: unknown, attempt: number) => boolean;
+    /**
+     * Number of retries until the execution fails
+     */
+    maxRetriesNumber: number;
+    /**
+     * Delay multiply factor
+     */
+    delayFactor?: number;
+    /**
+     * Delay min milliseconds
+     */
+    delayMinMs?: number;
+    /**
+     * Delay max milliseconds
+     */
+    delayMaxMs?: number;
+};
+/**
+ * @example
+ * await retryOnError({
+ *   maxRetriesNumber: 10,
+ *   delayFactor: 2,
+ *   delayMinMs: 1000,
+ *   delayMaxMs: 3000,
+ *   shouldRetryBasedOnError(error, attemptNumber) {
+ *     return error.code !== 'RECORD_EXISTS';
+ *   }
+ * }, async () => {
+ *   await db.transactions.insert(doc);
+ * });
+ *
+ * @group Errors
+ */
+declare function retryOnError<T extends AnyFunction>({ beforeRetryCallback, maxRetriesNumber, shouldRetryBasedOnError, delayFactor, delayMaxMs, delayMinMs, }: RetryOnErrorConfig, fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+
+/**
+ * Converts a string to camel case.
+ *
+ * Camel case is the naming convention in which the first word is written in lowercase and
+ * each subsequent word begins with a capital letter, concatenated without any separator characters.
+ *
+ * @param {string} str - The string that is to be changed to camel case.
+ * @returns {string} - The converted string to camel case.
+ *
+ * @example
+ * const convertedStr1 = camelCase('camelCase') // returns 'camelCase'
+ * const convertedStr2 = camelCase('some whitespace') // returns 'someWhitespace'
+ * const convertedStr3 = camelCase('hyphen-text') // returns 'hyphenText'
+ * const convertedStr4 = camelCase('HTTPRequest') // returns 'httpRequest'
+ * const convertedStr5 = camelCase('Keep unicode 😅') // returns 'keepUnicode😅'
+ *
+ * @group Strings
+ */
+declare function camelCase(str: string): string;
+
+/**
+ * Converts the first character of string to upper case and the remaining to lower case.
+ *
+ * @template T - Literal type of the string.
+ * @param {T} str - The string to be converted to uppercase.
+ * @returns {Capitalize<T>} - The capitalized string.
+ *
+ * @example
+ * const result = capitalize('fred') // returns 'Fred'
+ * const result2 = capitalize('FRED') // returns 'Fred'
+ *
+ * @group Strings
+ */
+declare function capitalize<T extends string>(str: T): Capitalize<T>;
+type Capitalize<T extends string> = T extends `${infer F}${infer R}` ? `${Uppercase<F>}${Lowercase<R>}` : T;
+
+/**
+ * Converts a value to a string and appends a specified unit to it.
+ * If the value is already a string, it returns it as is, and if the value is a number,
+ * it appends the specified unit (defaults to 'px'). If the value is null, undefined, or an empty string, it returns `undefined`.
+ *
+ * @example
+ * // Adding 'px' unit to a number
+ * convertToUnit(10, 'px'); // '10px';
+ *
+ * // Adding 'em' unit to a number
+ * convertToUnit(5, 'em'); // '5em';
+ *
+ * // Returning a string as is if it's not a number
+ * convertToUnit('100%', 'px'); // '100%';
+ *
+ * // Handling null, undefined, and empty string
+ * convertToUnit(null); // undefined;
+ * convertToUnit(''); // undefined;
+ *
+ * @param str - The value to convert, can be a number, string, null, or undefined.
+ * @param unit - The unit to append to the value. Defaults to 'px'.
+ * @returns The value with the unit appended, or `undefined` if the input is null, undefined, or an empty string.
+ *
+ * @group Strings
+ */
+declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+
+/**
+ * Sanitizes a string by escaping HTML syntax to prevent XSS (Cross-site scripting) attacks.
+ * Converts special HTML characters like `<`, `>`, `&`, etc., into their corresponding HTML entities.
+ *
+ * @example
+ * // Escaping HTML tags to prevent HTML injection
+ * escapeHtml('<b>Strong</b> man.'); // '&lt;b&gt;Strong&lt;/b&gt; man.'
+ *
+ * // Escaping other HTML special characters
+ * escapeHtml('<script>alert("XSS")</script>'); // '&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;'
+ *
+ * @param unsafe - The string to be sanitized (escaped).
+ * @returns A sanitized string with HTML special characters replaced by their corresponding HTML entities.
+ *
+ * @group Strings
+ */
+declare function escapeHtml(unsafe: string): string;
+
+/**
+ * Sanitizes a string by removing all non-numeric characters, leaving only digits.
+ * Useful for extracting numeric values from strings, such as when you want to
+ * extract a number from a string containing units or other non-numeric text.
+ *
+ * @example
+ * // Extracts numeric values from a string with units
+ * escapeNumeric('use 320px'); // '320'
+ *
+ * // Strips out non-numeric characters from a string
+ * escapeNumeric('USD 1,000.50'); // '100050'
+ *
+ * // Returns undefined if no numeric characters are found
+ * escapeNumeric('No numbers here!'); // undefined
+ *
+ * @param str - The input string to be sanitized.
+ * @returns A string containing only the numeric characters, or `undefined` if no numbers are found.
+ *
+ * @group Strings
+ */
+declare function escapeNumeric(str: string): string | undefined;
+
+/**
+ * Escapes special characters in a string to safely use it as a literal pattern in a regular expression.
+ * This function ensures that any characters that would otherwise have a special meaning in a regex
+ * (such as `*`, `+`, `?`, etc.) are properly escaped, allowing them to be used as normal characters
+ * in the pattern.
+ *
+ * @example
+ * // Escapes special characters in the string '[a|b]'
+ * escapeRegExp('[a|b]'); // '\\[a\\|b\\]'
+ *
+ * @example
+ * // Use the function to safely create a regex from user input
+ * const searchTerms = 'Andrew L.';
+ * const searchReg = new RegExp(escapeRegExp(searchTerms), 'i');
+ * const searchResult = users.find(v => searchReg.test(v.name));
+ *
+ * @param str - The string to escape for use in a regular expression.
+ * @returns The input string with all special regex characters escaped.
+ *
+ * @group Strings
+ */
+declare function escapeRegExp(str: string): string;
+
+/**
+ * Extracts the initials from a full name while ignoring titles or prefixes (e.g., Dr., Mr., Mrs.),
+ * as well as any words starting with special characters (e.g., !, @, #).
+ * Handles names with multiple words, ignores special characters, and ensures proper handling of Unicode characters.
+ *
+ * @param {string} fullName - The full name from which to extract initials.
+ * @returns {string} - The extracted initials in uppercase, or an empty string if the input is invalid.
+ *
+ * @example
+ * getInitials("John Doe");
+ * // Returns: "JD"
+ *
+ * @example
+ * getInitials("Dr. Alice Wonderland");
+ * // Returns: "AW"
+ *
+ * @example
+ * getInitials("José María de la Cruz");
+ * // Returns: "JC"
+ *
+ * @example
+ * getInitials("Mr. Albert Einstein");
+ * // Returns: "AE"
+ *
+ * @example
+ * getInitials("Invalid Name");
+ * // Returns: "IN"
+ *
+ * @example
+ * getInitials("");
+ * // Returns: ""
+ *
+ * @group Strings
+ */
+declare function getInitials(fullName: string): string;
+
+declare function getWords(str?: string): string[];
+
+/**
+ * Checks if the provided URL string has a protocol prefix, such as `http://` or `https://`.
+ * The function checks whether the URL starts with any of the specified protocols (defaults to HTTP and HTTPS).
+ *
+ * This can be useful for validating URLs or ensuring a URL has a valid protocol before using it in network requests.
+ *
+ * @example
+ * hasProtocol('https://google.com'); // true
+ * hasProtocol('http://google.com'); // true
+ * hasProtocol('google.com'); // false
+ *
+ * @param url - The URL string to check.
+ * @param protocols - An array of protocol prefixes to check against (defaults to `['http://', 'https://']`).
+ * @returns `true` if the URL starts with one of the provided protocols, `false` otherwise.
+ *
+ * @group Strings
+ */
+declare function hasProtocol(url: string, protocols?: string[]): boolean;
+
+/**
+ * Encodes a `Uint8Array` or a number array into a hexadecimal string.
+ * Each byte of the array is converted to its corresponding two-character hex representation.
+ *
+ * This function is useful when you need to represent binary data as a string of hexadecimal characters.
+ *
+ * @example
+ * console.log(hex(new Uint8Array([255]))); // 'ff'
+ * console.log(hex([255, 0, 128])); // 'ff0080'
+ *
+ * @param value - The array to be converted, either a `Uint8Array` or a number array.
+ * @returns A string of hexadecimal characters representing the array's byte values.
+ *
+ * @group Strings
+ */
+declare function hex(value: Uint8Array | number[]): string;
+
+/**
+ * Checks if the provided text is a single emoji.
+ * The function uses a regular expression to match the emoji and ensures that the entire string is a valid single emoji.
+ *
+ * @param {unknown} text - The input value to check.
+ * @returns {boolean} - Returns `true` if the input is a single emoji, otherwise `false`.
+ *
+ * @example
+ * isOneEmoji("😊"); // Returns: true
+ * isOneEmoji("Hello 😊"); // Returns: false
+ * isOneEmoji("😎"); // Returns: true
+ * isOneEmoji("👨‍👩‍👧‍👦"); // Returns: true (family emoji with multiple characters)
+ * isOneEmoji("not an emoji"); // Returns: false
+ *
+ * @group Strings
+ */
+declare function isOneEmoji(text: unknown): text is string;
+
+/**
+ * Converts a two-letter ISO country code (e.g., 'US') to the corresponding flag emoji.
+ * If the input is not a valid two-letter country code, it returns the original string.
+ *
+ * @param {string} iso - The two-letter ISO country code.
+ * @returns {string} - The corresponding country flag emoji or the original input if it's invalid.
+ *
+ * @example
+ * isoToFlagEmoji("US"); // Returns: 🇺🇸
+ * isoToFlagEmoji("GB"); // Returns: 🇬🇧
+ * isoToFlagEmoji("DE"); // Returns: 🇩🇪
+ * isoToFlagEmoji("xyz"); // Returns: "xyz" (invalid code)
+ *
+ * @group Strings
+ */
+declare function isoToFlagEmoji(iso: string): string;
+
+/**
+ * Converts a string to kebab case.
+ *
+ * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character.
+ *
+ * @param {string} str - The string that is to be changed to kebab case.
+ * @returns {string} - The converted string to kebab case.
+ *
+ * @example
+ * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case'
+ * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace'
+ * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text'
+ * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request'
+ *
+ * @group Strings
+ */
+declare function kebabCase(str: string): string;
+
+/**
+ * Converts a string to lower case.
+ *
+ * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character.
+ *
+ * @param {string} str - The string that is to be changed to lower case.
+ * @returns {string} - The converted string to lower case.
+ *
+ * @example
+ * const convertedStr1 = lowerCase('camelCase') // returns 'camel case'
+ * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace'
+ * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text'
+ * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request'
+ *
+ * @group Strings
+ */
+declare const lowerCase: (str?: string) => string;
+
+/**
+ * Masks part of the email address to provide a simple level of privacy.
+ * The username part is partially masked with asterisks, while the domain remains intact.
+ *
+ * ⚠️ Returns an empty string if the provided value is invalid.
+ *
+ * @example
+ * maskingEmail('andrew@gmail.com'); // 'a****w@gmail.com'
+ * maskingEmail('user@domain.com'); // 'u***r@domain.com'
+ * maskingEmail('invalidemail'); // ''
+ *
+ * @param value - The email address to be masked.
+ * @returns The masked email address or an empty string if the value is invalid.
+ *
+ * @group Strings
+ */
+declare function maskingEmail(value: string): string;
+
+/**
+ * Masks part of a phone number to provide a simple level of privacy.
+ * The function replaces digits in a specified range with a given character.
+ * Supports formatted phone numbers (e.g., `(000) 000-11-11`).
+ *
+ * ⚠️ Returns an empty string if the provided value is invalid.
+ *
+ * @example
+ * maskingPhone('+18000551100'); // '+18XXXXX1100'
+ * maskingPhone('+18000551100', 2, 4, '*'); // '+18*****1100'
+ * maskingPhone('+1 800-055-1100'); // '+1 8XX-XXX-1100'
+ * maskingPhone('+1234567890', 3, 5, 'X'); // '+1XXX567890'
+ *
+ * @param value - The phone number to be masked.
+ * @param [fromPosition=2] - The starting position from left side where masking begins (default is 2).
+ * @param [toPosition=4] - The position from right side where masking ends (default is 4).
+ * @param [withChar='X'] - The character used to replace digits (default is 'X').
+ * @returns The masked phone number or an empty string if the value is invalid.
+ *
+ * @group Strings
+ */
+declare function maskingPhone(value: string, fromPosition?: number, toPosition?: number, withChar?: string): string;
+
+/**
+ * Masks the middle characters of each word in the given string, leaving the first and last characters intact.
+ * The characters in the middle of each word are replaced by a specified masking character (default is `*`).
+ *
+ * ⚠️ If the provided value is not a valid string, the function returns an empty string.
+ *
+ * **Note**: This function does not perform any validation or checks for non-alphabetic characters within words.
+ * It simply masks all characters between the first and last character of each word.
+ *
+ * @param {string} value - The input string containing words to be masked.
+ * @param {string} [withChar='*'] - The character used to replace the middle characters of each word. Default is `*`.
+ *
+ * @returns {string} The input string with middle characters of words masked, or an empty string if the input is invalid.
+ *
+ * @example
+ * maskingWords('hello world'); // 'h**o w**d'
+ * maskingWords('John Doe');    // 'J**n D**e'
+ * maskingWords('a b c');       // '* * *'
+ *
+ * @group Strings
+ */
+declare function maskingWords(value: string, withChar?: string): string;
+
+/**
+ * Useful when you need to generate almost secure object id in browser
+ *
+ * Based on [bson](https://github.com/mongodb/js-bson/blob/main/src/objectid.ts)
+ *
+ * @example
+ * const userId = objectId(); // '67350af7885ba34010c83859'
+ *
+ * @group Strings
+ */
+declare function objectId(fromValue?: number | Date): string;
+
+/**
+ * Generates a random string of the specified length using characters from a predefined set.
+ * The characters used in the generated string include lowercase letters (a-z) and digits (0-9).
+ *
+ * @param {number} length - The length of the random string to generate. Must be a positive integer.
+ *
+ * @returns {string} A random string of the specified length, composed of characters from 'a-z' and '0-9'.
+ *
+ * @example
+ * randomString(8);  // e.g. 'a1b2c3d4'
+ * randomString(12); // e.g. '3f6g7h8i9j0k'
+ * randomString(5);  // e.g. '1a2b3'
+ *
+ * @group Strings
+ */
+declare function randomString(length: number): string;
+
+/**
+ * Converts a string to snake case.
+ *
+ * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character.
+ *
+ * @param {string} str - The string that is to be changed to snake case.
+ * @returns {string} - The converted string to snake case.
+ *
+ * @example
+ * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case'
+ * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace'
+ * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text'
+ * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request'
+ *
+ * @group Strings
+ */
+declare const snakeCase: (str?: string) => string;
+
+/**
+ * Formats a string by replacing format specifiers with values from the provided arguments.
+ * It supports a variety of format types, including strings, numbers, and objects.
+ *
+ * ⚠️ This function mutates the `unusedArgs` array, which will contain any arguments
+ * that were not used in the formatting process.
+ *
+ * @param line - The format string containing placeholders to be replaced by arguments.
+ *   Format specifiers are indicated by the `%` symbol, followed by a character indicating
+ *   the type of argument to insert (e.g., `%s` for string, `%d` for integer, `%f` for float).
+ * @param args - The array of arguments to replace the format specifiers in the string.
+ *   The function will iterate over the arguments and substitute them into the format string
+ *   in the order they appear.
+ * @param [unusedArgs=[]] - The array that will collect any unused arguments
+ *   that were not needed for formatting. This array is mutated by the function.
+ *
+ * @returns {string} The formatted string with placeholders replaced by corresponding arguments.
+ *
+ * @example
+ * const unusedArgs: any[] = [];
+ *
+ * console.log(sprintf('Hello %s', ['World', 'Great'], unusedArgs));
+ * // Output: 'Hello World'
+ * console.log(unusedArgs);
+ * // Output: ['Great']
+ *
+ * @example
+ * console.log(sprintf('I have %d apples and %f.5 liters of water.', [5, 3.2], unusedArgs));
+ * // Output: 'I have 5 apples and 3.2 liters of water.'
+ * console.log(unusedArgs);
+ * // Output: []
+ *
+ * @group Strings
+ */
+declare function sprintf(line: string, args: any[], unusedArgs?: any[]): string;
+
+/**
+ * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase.
+ *
+ * Start case is the naming convention in which each word is written with an initial capital letter.
+ * @param {string} str - The string to convert.
+ * @returns {string} The converted string.
+ *
+ * @example
+ * const result1 = startCase('hello world');  // result will be 'Hello World'
+ * const result2 = startCase('HELLO WORLD');  // result will be 'Hello World'
+ * const result3 = startCase('hello-world');  // result will be 'Hello World'
+ * const result4 = startCase('hello_world');  // result will be 'Hello World'
+ *
+ * @group Strings
+ */
+declare const startCase: (value?: string) => string;
+
+/**
+ * Replaces placeholders in the input string with values from the provided object.
+ * The placeholders are denoted by `{{ key }}` syntax, where `key` is a property name in the object.
+ * The function optionally allows a custom method to handle how the values are retrieved from the object.
+ *
+ * @param {string} str - The string with placeholders to be replaced. Placeholders are in the form of `{{key}}`.
+ * @param {T} obj - The object whose properties will be used to replace the placeholders in the string.
+ * @param method - An optional custom method
+ *   to retrieve values from the object. The default method retrieves
+ *   the values by accessing the object property directly using the `key`.
+ *
+ * @returns {string} The string with placeholders replaced by the corresponding values from the object.
+ *
+ * @example
+ * const context = { name: 'Andrew', age: 30 };
+ * console.log(strAssign('Hey {{ name }}! You are {{ age }} years old.', context));
+ * // Output: 'Hey Andrew! You are 30 years old.'
+ *
+ * @example
+ * // Using a custom method
+ * const context2 = { firstName: 'Andrew', lastName: 'L.' };
+ * const customMethod = (obj, key) => {
+ *   if (key === 'name') {
+ *     return obj.firstName + ' ' + obj.lastName;
+ *   }
+ *   return obj[key];
+ * };
+ * console.log(strAssign('Hello {{ name }}!', context2, customMethod));
+ * // Output: 'Hello Andrew L.!'
+ *
+ * @group Strings
+ */
+declare function strAssign<T extends object>(str: string, obj: T, method?: (obj: T, key: string) => any): string;
+
+/**
+ * Truncates a string to the specified maximum length while preserving whole words
+ * and appends ellipsis (`...`) if the string exceeds the maximum length.
+ * Ensures that truncation does not occur if the difference is insignificant
+ * (less than 5% of the original string length).
+ *
+ * @param {string} str - The input string to truncate.
+ * @param {number} maxLength - The maximum allowed length for the string.
+ * @param {number} insignificantThreshold - The insignificance threshold as a fraction of the original string length (default is 5%)
+ * @returns {string} - The truncated string with ellipsis if applicable.
+ *
+ *
+ * @example
+ * // Basic truncation
+ * truncate("This is a test string for truncation.", 20);
+ * // Returns: "This is a test..."
+ *
+ * @example
+ * // No truncation needed as the string length is within the limit
+ * truncate("Short string", 20);
+ * // Returns: "Short string"
+ *
+ * @example
+ * // No truncation because the difference is insignificant
+ * truncate("This string has an insignificant truncation.", 40);
+ * // Returns: "This string has an insignificant truncation."
+ *
+ * @example
+ * // Handles strings with no spaces gracefully
+ * truncate("ThisStringHasNoSpacesButIsVeryLong", 10);
+ * // Returns: "ThisString..."
+ *
+ * @group Strings
+ */
+declare function truncate(value: string, maxLength?: number, insignificantThreshold?: number): string;
+
+declare function removeVS16s(rawEmoji: string): string;
+declare const _default: RegExp;
+
+/**
+ * Truncates the input string to the specified maximum length and appends an ellipsis (`...`)
+ * if the string exceeds the maximum length. If the string is shorter than or equal to the
+ * maximum length, it is returned unchanged.
+ *
+ * Unlike the `truncate` function, the result can be truncated in the middle of a word
+ *
+ * @param {string} value - The input string to truncate.
+ * @param {number} maxLength - The maximum allowed length for the string (default is 30).
+ * @returns {string} - The truncated string with ellipsis (`...`) if necessary.
+ *
+ * @example
+ * wrapText("This is a long string", 10); // Returns: "This is a..."
+ * wrapText("Short text", 20); // Returns: "Short text"
+ * wrapText("Another long string example", 15); // Returns: "Another long..."
+ *
+ * @group Strings
+ */
+declare function wrapText(value: string, maxLength?: number): string;
+
+/**
+ * Transform value to error object
+ * @group Errors
+ */
+declare function toError<T>(value: T, unknownMessage?: string): T extends Error ? T : Error;
+
+export { type AnyFunction, AppError, type ArgumentsType, type Arrayable, AsyncIterableQueue, type Awaitable, BrowserAssertionError, CancellablePromise, Color, type ColorChannels, ColorParser, type Data, type DeepPartial, type Defer, type EnvParser, type ExecResult, type ExecResultToSkip, type ExecResultToSuccess, type ExecSkip, type ExecSuccess, FixedMap, FixedWeakMap, type Fn, type FormatMoney, type FormatNumber, type FunctionArgs, type GenericObject, type IfAny, type IsAny, type LiteralUnion, type Logger, LruCache, type Nothing, type OverwriteWith, type Prettify, type Primitive, type PromisifyFn, Queue, type RandomizerOptions, type RetryOnErrorConfig, type SelectOptionItem, type SelectOptions, type SimpleDefaultEventMap, SimpleEventEmitter, type SimpleEventMap, _default as TWEMOJI_REGEX, type ThemeConfig, TimeBucket, type TimeBucketOptions, type TimeObject, type TypeOf, type TypeOfMap, type ValuesOfObject, type WithCache, type WithCacheBucketBatchOptions, type WithCacheBucketOptions, type WithCacheFixedOptions, type WithCacheLruOptions, type WithCacheOptions, type WithCachePointer, type WithCacheResult, type WithCacheStorage, type WithCustomizer, type WithCustomizerFactory, type WithCustomizerValue, alpha, arrayable, assert, asyncFilter, asyncFind, asyncForEach, asyncMap, avg, blendColors, buildCssColor, cache, cacheBucket, cacheFixed, cacheLRU, camelCase, capitalize, captureStackTrace, catchError, channelsToHSL, channelsToHex, channelsToRGB, checkBitmask, chunk, chunkSeries, clamp, cleanEmpty, cleanObject, colorToChannels, contrastRatio, convertToUnit, crc32, createCustomizer, createCustomizerFactory, createDeepCloneWith, createEnvParser, createRandomizer, createSecureCustomizer, createWithCache, cssVariable, deepAssign, deepClone, deepCloneWith, deepDefaults, deepFreeze, def, defer, delay, dropCache, env, escapeHtml, escapeNumeric, escapeRegExp, fastIdle, fastIdlePromise, fastRaf, findMean, flagsToMap, flatten, formatMoney, formatNumber, get, getFileExtension, getFileName, getInitials, getRandomInt, getWords, has, hasOwn, hasProtocol, hex, hexToChannels, hslToChannels, humanFileSize, humanize, interpolateColor, isBigInt, isBoolean, isCached, isClient, isColorChannels, isCustomizerFactory, isDate, isDef, isEmpty, isEqual, isError, isFunction, isMap, isNullOrUndefined, isNumber, isObject, isOneEmoji, isPrimitive, isPromise, isSet, isSkip, isString, isSuccess, isSymbol, isWeakMap, isWeakSet, isWithCache, isoToFlagEmoji, kebabCase, keyBy, logger, lowerCase, luminance, maskingEmail, maskingPhone, maskingWords, nextTickIteration, noop, objectId, omit, omitPrefixed, orderBy, parseAllNumbers, parseAlpha, parsePercentage, percentOf, pick, pickPrefixed, qs, rafPromise, randomString, removeVS16s, retryOnError, rgbToChannels, round2digits, set, snakeCase, sprintf, startCase, strAssign, sum, timeout, timestamp, timestampToDate, tintedTextColor, toError, toMap, truncate, typeOf, unflatten, union, uniq, uniqBy, unset, withCache, withCacheBucket, withCacheBucketBatch, withCacheFixed, withCacheLRU, withDeepClone, withPointerCache, wrapText };