toolbox-x 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1493 @@
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { $ as Maybe, $n as ProtoMethodOptions, $t as LocaleCode, B as BasicPrimitive, Bt as ConvertOptions, Cn as ArrayOfObjectsToStringOptions, D as NumericDotKey, E as NestedPrimitiveKey, F as SanitizedData, H as ClassDetails, Ht as CurrencyCode, Kt as FrankFurterCurrency, O as Objects, P as SanitizeOptions, R as Any, U as Constructor, Ut as DecimalOptions, Vt as ConvertedDecimal, W as DelayedFn, Y as FlattenPartial, a as ConvertObjectOptions, an as RandomNumberOptions, at as OwnKeys, c as DeepKeys, cn as RomanCapital, dr as Tuple, en as LooseRomanNumeral, g as FlattenDotValue, gr as Unit, in as PercentageOptions, it as Numeric, nn as NumberType, o as ConvertedObject, on as RangeOptions, ot as PartialOrRequired, p as ExpandAll, s as CountryDetails, sn as RangedNumbers, st as Primitive, u as DotNotationKey, ut as VoidFn, v as FlattenLeafValue, w as MergeAll, wn as ArrayOfPrimitivesToStringOptions, y as GenericObject, zt as BnDigitResult } from "./object-B0TV3eHx.mjs";
+import { A as MaskOptions, d as AnagramOptions, h as CharDiffResult, w as DiffResult } from "./string-CBAbxaG1.mjs";
+import { n as convertStringCase, t as capitalizeString } from "./case-CybASFPD.mjs";
+import { n as trimString, r as truncateString, t as generateRandomID } from "./basics-uBSfkBEI.mjs";
+import { a as Flattened, c as OrderOption, l as SortByOption, n as FindOptions, s as OptionsConfig, t as FieldValue, u as SortNature } from "./array-DvW0zIu6.mjs";
+
+//#region src/string/anagram.d.ts
+/**
+ * * Generates unique anagrams of a given word. Optionally looks up valid anagrams inside a provided dictionary.
+ *
+ * @param word The word from which to generate anagrams. Converted to lowercase internally.
+ *
+ * @param options Controls the output limit and optional dictionary lookup.
+ *
+ * @returns A list of unique, lowercase anagrams. The original word (lowercased) is always included as the first element.
+ *
+ * @remarks
+ * - When a dictionary is provided, only anagrams found inside that dictionary are returned.
+ * - The dictionary is cached internally (with converting to lowercase) using a `WeakMap`, allowing garbage collection of unused inputs.
+ * - Repeated letters are handled efficiently using a per-level set to avoid duplicate permutations.
+ *
+ * @example
+ * generateAnagrams("east", { limit: 10 });
+ *
+ * @example
+ * generateAnagrams("tone", {
+ *   dictionary: ["tone", "note", "one"],
+ *   limit: "all"
+ * });
+ */
+declare function generateAnagrams(word: string, options?: AnagramOptions): Lowercase<string>[];
+//#endregion
+//#region src/string/convert.d.ts
+/**
+ * * Replaces all occurrences of a string or pattern in the given input string.
+ *
+ * - If `find` is a string, it is converted into a global regular expression (`/find/g`).
+ * - If `find` is a `RegExp`, the global (`g`) flag is ensured.
+ * - Trims the input before performing replacements.
+ *
+ * @param input - The string in which replacements should be performed.
+ * @param find - The substring or regex pattern to search for.
+ * @param replace - The string to replace matches with.
+ * @returns The modified/refined string with replacements applied.
+ */
+declare const replaceAllInString: (input: string, find: string | RegExp, replace: string) => string;
+/**
+ * * Converts a string into a URL-friendly slug.
+ * @param input - The string to be converted.
+ * @returns The slugified string.
+ */
+declare const slugifyString: (input: string) => string;
+/**
+ * * Masks part of a string for privacy.
+ * @param input - The string to mask.
+ * @param options - Options for masking a string.
+ * @returns The masked string.
+ */
+declare const maskString: (input: string, options?: MaskOptions) => string;
+/**
+ * * Reverses a given string.
+ * @param input - The string to reverse.
+ * @returns The reversed string.
+ */
+declare const reverseString: (input: string) => string;
+/**
+ * * Normalizes a string by removing diacritics (accents).
+ * @param str The input string.
+ * @returns The normalized string.
+ */
+declare function normalizeString(str: string): string;
+/**
+ * * Extracts all email addresses from a string.
+ * @param str The input string.
+ * @returns An array of extracted email addresses.
+ */
+declare function extractEmails(str: string): string[];
+/**
+ * * Extracts all URLs from a string.
+ * @param str The input string.
+ * @returns An array of extracted URLs.
+ */
+declare function extractURLs(str: string): string[];
+/**
+ * * Returns a grammatically correct unit string, optionally prefixed with the number.
+ *
+ * @remarks For complex and versatile pluralization, please refer to {@link https://toolbox.nazmul-nhb.dev/docs/utilities/string/pluralizer pluralizer} or {@link https://toolbox.nazmul-nhb.dev/docs/classes/Pluralizer Pluralizer Class} instead.
+ *
+ * @param count The numeric value to determine singular or plural.
+ * @param unit The unit name (e.g., "day", "hour").
+ * @param withNumber Whether to prefix the count before the unit. Defaults to `true`.
+ * @returns Formatted unit string like `"1 day"`, `"2 months"`, or `"hour"`.
+ */
+declare function formatUnitWithPlural(count: number, unit: string, withNumber?: boolean): string;
+//#endregion
+//#region src/string/diff.d.ts
+/**
+ * * Computes a line-based text diff between two strings using the Longest Common Subsequence (LCS) algorithm.
+ *
+ * @remarks
+ * - Lines are classified as `added`, `removed`, `modified`, or `unchanged`.
+ * - Detects and pairs similar `removed` and `added` lines as `modified` when their similarity exceeds the threshold.
+ *
+ * @param originalText The original (before) text.
+ * @param modifiedText The modified (after) text.
+ * @returns A {@link DiffResult} with the list of diff lines and summary statistics.
+ *
+ * @example
+ * const result = computeTextDiff('hello\nworld', 'hello\nearth');
+ * // result.stats → { linesAdded: 1, linesRemoved: 1, linesChanged: 0, linesUnchanged: 1 }
+ *
+ * @example
+ * const result = computeTextDiff('foo\nbar', 'foo\nbaz\nqux');
+ * result.stats.linesAdded;   // 1
+ * result.stats.linesChanged; // 1
+ */
+declare function computeTextDiff(originalText: string, modifiedText: string): DiffResult;
+/**
+ * * Highlights character-level differences between two strings using the LCS algorithm.
+ *
+ * @remarks
+ * - The function returns two arrays of characters for the original and modified strings.
+ * - Each character in both strings is annotated with a `highlighted` flag indicating whether it differs from the other string.
+ *
+ * @param original The original string to compare from.
+ * @param modified The modified string to compare to.
+ * @returns A {@link CharDiffResult} with annotated character arrays for both strings.
+ *
+ * @example
+ * const diff = getCharacterDifferences('cat', 'car');
+ * diff.original; // [{ text: 'c', highlighted: false }, { text: 'a', highlighted: false }, { text: 't', highlighted: true }]
+ * diff.modified; // [{ text: 'c', highlighted: false }, { text: 'a', highlighted: false }, { text: 'r', highlighted: true }]
+ *
+ * @example
+ * // When one string is empty, all characters in the other are highlighted
+ * getCharacterDifferences('', 'hi');
+ * // { original: [], modified: [{ text: 'h', highlighted: true }, { text: 'i', highlighted: true }] }
+ *
+ * @example
+ * const diff = getCharacterDifferences('hello world', 'hello earth');
+ * // Characters unique to each string will have highlighted: true
+ */
+declare function getCharacterDifferences(original: string, modified: string): CharDiffResult;
+//#endregion
+//#region src/string/utilities.d.ts
+/**
+ * * Extracts all numbers from a string as array of numbers.
+ * @param input - The string to extract numbers from.
+ * @returns An array of numbers found in the string.
+ */
+declare const extractNumbersFromString: (input: string) => number[];
+/**
+ * * Computes the Levenshtein distance between two strings (space optimized).
+ * @param str1 - First string to compare.
+ * @param str2 - Second string to compare.
+ * @returns The Levenshtein distance between the two strings.
+ *
+ * @remarks
+ * - The Levenshtein distance is the minimum number of single-character edits (insertions, deletions, or substitutions) required to change one string into the other.
+ * - This implementation uses only O(min(len(a), len(b))) space by keeping only the current and previous rows of the distance matrix.
+ *
+ * @example
+ * const distance = getLevenshteinDistance('kitten', 'sitting');
+ * console.log(distance); // Output: 3
+ */
+declare const getLevenshteinDistance: (str1: string, str2: string) => number;
+/**
+ * * Counts the number of words in a string, supporting multiple languages and scripts.
+ *
+ * @param text - The input string to count words from.
+ * @returns Number of words (Unicode-aware).
+ */
+declare function countWords(text: string): number;
+//#endregion
+//#region src/number/basics.d.ts
+/**
+ * * Utility to generate a random number between a given range.
+ * * If no options are provided, it will generate a random number between `0` and `100` (inclusive).
+ * * If `min` is greater than `max`, it will swap the values and generate a random number.
+ *
+ * @param options - Options for configuring random number generator.
+ * @returns Random number.
+ */
+declare const getRandomNumber: (options?: RandomNumberOptions) => number;
+/**
+ * * Utility to round a number to given decimal places.
+ *
+ * @param input - Number or `stringified` number to round.
+ * @param options - Options for rounding behavior, including decimal places and return type.
+ * @returns Converted number as `number` (default) or `string` (if `isString` is `true`).
+ */
+declare const convertToDecimal: <T extends Maybe<boolean> = false>(input: Numeric, options?: DecimalOptions<T>) => ConvertedDecimal<T>;
+/**
+ * * Calculates the HCF/GCD of multiple numbers.
+ *
+ * @param numbers - List of numbers to find the HCF/GCD for.
+ * @returns The HCF/GCD of all the provided numbers.
+ */
+declare const calculateHCF: (...numbers: Numeric[]) => number;
+/**
+ * * Calculates the LCM/LCD of multiple numbers.
+ *
+ * @param numbers - List of numbers to find the LCM/LCD for.
+ * @returns The LCM/LCD of all the provided numbers.
+ */
+declare const calculateLCM: (...numbers: Numeric[]) => number;
+/**
+ * * Computes the factorial of a non-negative numeric value (integer).
+ *
+ * @param int - A numeric input value (integer) whose factorial should be calculated.
+ *
+ * @returns The factorial result as a number if valid, otherwise `undefined`.
+ *
+ * @example
+ * factorial(5); // → 120
+ * factorial(0); // → 1
+ * factorial(-3); // → undefined
+ * factorial(undefined); // → undefined
+ * factorial(5.5); // → undefined
+ *
+ * @remarks
+ * - Factorial of `0` and `1` is `1`.
+ * - Uses recursive approach internally.
+ * - Input is normalized via `normalizeNumber` before computation.
+ * - May return large values quickly due to factorial growth rate.
+ * - Returns `undefined` if the input is negative, not numeric, non-integer, or `undefined`.
+ */
+declare function factorial(int: Maybe<Numeric>): Maybe<number>;
+/**
+ * * Efficiently computes all positive integer factors (divisors) of a number.
+ *
+ * @param int - Numeric value to find factors for. Non-integer or negative values return an empty array.
+ *
+ * @returns An array of positive factors in ascending order.
+ *
+ * @example
+ * getFactors(12); // → [1, 2, 3, 4, 6, 12]
+ * getFactors(7);  // → [1, 7]
+ * getFactors(-4); // → []
+ * getFactors(undefined); // → []
+ *
+ * @remarks
+ * - Uses the square root method for better performance (`O(√n)`).
+ * - Returns an empty array for invalid, negative, or non-integer input.
+ */
+declare function getFactors(int: Maybe<Numeric>): number[];
+/**
+ * * Sums up all digits of a number.
+ *
+ * @param num The input number.
+ * @returns The sum of its digits.
+ */
+declare function sumDigits(num: Numeric): number;
+/**
+ * * Sums up numbers.
+ *
+ * @param numbers The input numbers.
+ * @returns The sum of the numbers.
+ */
+declare function sumNumbers(...numbers: Numeric[]): number;
+/**
+ * * Reverses a number (e.g., `123` → `321`).
+ *
+ * @param num The number to reverse.
+ * @returns The reversed number.
+ */
+declare function reverseNumber(num: Numeric): number;
+/**
+ * * Calculates the average of a set of numbers.
+ *
+ * @param numbers - A list of numbers for which to calculate the average.
+ * @returns The average of the provided numbers. Returns `NaN` if no numbers are valid.
+ */
+declare function getAverage(...numbers: Numeric[]): number;
+/**
+ * * Rounds a number to a specified number of decimal places.
+ *
+ * @param number - The number to round.
+ * @param roundTo - The number of decimal places to round to (default is `2`).
+ * - If `roundTo` is negative, the number is rounded to the left of the decimal point (e.g., `-1` rounds to the nearest 10, `-2` to nearest 100 etc.).
+ * @returns The rounded number, either in float or integer (if a whole number).
+ *
+ * @example
+ * roundNumber(1234.56, -2); // 1200
+ * roundNumber(1234.56, 1);  // 1234.6
+ */
+declare function roundNumber(number: Numeric, roundTo?: number): number;
+//#endregion
+//#region src/number/Currency.d.ts
+/**
+ * * A utility class for handling currency operations like formatting and conversion.
+ *
+ * - Supports formatting based on locale and currency code.
+ * - Converts between **fiat currencies supported by `api.frankfurter.app`**.
+ * - Automatically caches conversion rates to reduce redundant API calls.
+ * - Intended for use with numeric inputs (number or numeric string).
+ */
+declare class Currency<Code extends CurrencyCode> {
+  #private;
+  /**
+   * * The formatted currency string (e.g., `$1,000.00`).
+   *
+   * - Generated using the `en-US` locale during construction.
+   * - This is a display-friendly version of the currency value.
+   * - For formatting with other locales, use the `format()` method.
+   */
+  readonly currency: string;
+  /**
+   * Creates an instance of the Currency class.
+   *
+   * @param amount - The numeric amount of currency (e.g., `100`, `'99.99'`).
+   * @param code - The ISO 4217 currency code representing the currency (e.g., `'USD'`, `'EUR'`).
+   */
+  constructor(amount: Numeric, code: Code);
+  /** * Clears cached rates that were fetched previously. */
+  static clearRateCache(): void;
+  /**
+   * @instance Formats the stored amount as a localized currency string.
+   *
+   * @param locale - Optional. A BCP 47 locale string (e.g., `'de-DE'`, `'en-US'`). Defaults to `'en-US'` if not provided.
+   * @param code - Optional. An ISO 4217 currency code (e.g., `'USD'`, `'EUR'`) used solely for formatting purposes.
+   *            _This does not alter the internal currency code set during instantiation._
+   * @returns A string representing the formatted currency value according to the specified locale and currency code.
+   */
+  format(locale?: LocaleCode, code?: CurrencyCode): string;
+  /**
+   * @instance Converts the current currency amount to a target currency using real-time exchange rates.
+   *
+   * - Uses {@link https://api.frankfurter.app/latest api.frankfurter.app} to fetch live exchange rates.
+   * - Supports **only the following fiat currencies**:
+   *   `AUD`, `BGN`, `BRL`, `CAD`, `CHF`, `CNY`, `CZK`, `DKK`, `EUR`, `GBP`, `HKD`, `HUF`, `IDR`, `ILS`, `INR`, `ISK`, `JPY`,
+   *   `KRW`, `MXN`, `MYR`, `NOK`, `NZD`, `PHP`, `PLN`, `RON`, `SEK`, `SGD`, `THB`, `TRY`, `USD`, `ZAR`.
+   * - Uses cached rates unless `forceRefresh` is set to `true`.
+   * - If API fails or currency not supported, falls back to `fallbackRate` if provided.
+   * - Use {@link convertSync} method to convert to other currencies using custom exchange rate.
+   *
+   * @param to - The target currency code (must be one of the supported ones, e.g., `'EUR'`, `'USD'`).
+   * @param options - Optional settings:
+   *   - `fallbackRate`: A manual exchange rate to use if the API call fails or currency is not supported.
+   *   - `forceRefresh`: If true, ignores cached rates and fetches fresh data.
+   * @returns A new `Currency` instance with the converted amount in the target currency.
+   * @throws Will throw error if the API call fails and no `fallbackRate` is provided.
+   *
+   * @example
+   * await new Currency(100, 'USD').convert('EUR');
+   */
+  convert<To extends FrankFurterCurrency>(to: To, options?: ConvertOptions): Promise<Currency<To>>;
+  /**
+   * @instance Converts the current currency amount to a target currency using either a cached rate or a manual exchange rate.
+   *
+   * - This method is **synchronous** and does **not perform any network requests**.
+   * - If a cached rate exists for the currency pair, it is used.
+   * - If no cached rate is found, `rate` is used as a manual exchange rate.
+   * - If neither are available, the original instance is returned unchanged.
+   *
+   * @param to - The target currency code to convert to.
+   * @param rate - A manual exchange rate to use if no cached rate is available.
+   * @returns A new `Currency` instance with the converted amount, or the original instance if no rate is available.
+   *
+   * @example
+   * const usd = new Currency(100, 'USD');
+   * const eur = usd.convertSync('EUR', 0.92);
+   *
+   * console.log(eur.currency); // €92.00
+   */
+  convertSync<To extends CurrencyCode>(to: To, rate: number): Currency<To>;
+}
+//#endregion
+//#region src/number/percent.d.ts
+/**
+ * * Performs a percentage-related calculation based on the given mode and inputs.
+ *
+ * - `get-percent`: Calculates what percentage the `part` is of the `total`.
+ * - `get-value`: Calculates the value from a given `percentage` of a `total`.
+ * - `get-original`: Calculates the original value from a known `value` and `percentage`.
+ * - `get-change-percent`: Percent increase/decrease from `oldValue` to `newValue`.
+ * - `apply-percent-change`: Applies increase/decrease by `percentage` to `baseValue`.
+ * - `get-percent-difference`: Absolute percent difference between two values.
+ * - `inverse-percent`: What percent `total` is of `part`.
+ *
+ * @param options - The calculation mode and inputs required for the operation.
+ * @returns The calculated number rounded to three decimal places, or `NaN` if input is invalid.
+ */
+declare function calculatePercentage(options: PercentageOptions): number;
+//#endregion
+//#region src/number/fibonacci.d.ts
+/**
+ * * Generates the first `limit` Fibonacci numbers.
+ *
+ * @param limit The number of Fibonacci numbers to generate.
+ * @returns An array containing the first `limit` Fibonacci numbers.
+ */
+declare function getFibonacciSeries(limit: Numeric): number[];
+/**
+ * * Generates the first `limit` Fibonacci numbers using recursion with memoization.
+ *
+ * @param limit - The number of Fibonacci numbers to generate.
+ * @returns An array containing the first `limit` Fibonacci numbers.
+ */
+declare function getFibonacciSeriesMemo(limit: Numeric): number[];
+/**
+ * * Generator function for Fibonacci sequence up to a given limit.
+ *
+ * @param limit - Number of Fibonacci numbers to generate.
+ * @param onYield - Optional callback triggered on each yield with the current value and index.
+ * @returns A generator yielding Fibonacci numbers one by one.
+ */
+declare function fibonacciGenerator(limit: Numeric, onYield?: (value: number, index: number) => void): Generator<number, void, void>;
+/**
+ * * Calculates the `n`th Fibonacci number using optimized space.
+ *
+ * @param index - The index (0-based) of the Fibonacci number.
+ * @returns The index=`n`th Fibonacci number.
+ */
+declare function getNthFibonacci(index: Numeric): number;
+//#endregion
+//#region src/number/convert.d.ts
+/**
+ * * Converts a numeric value into its corresponding English word representation.
+ * @warning ***Supports numeric values up to `10e19` or `10^20` (one hundred quintillion).***
+ * @warning ***Decimal values are ignored; only the integer part is converted.***
+ * @param number - The number to convert into words.
+ * @returns The number converted in words.
+ */
+declare function numberToWords(num: Numeric): string;
+/**
+ * * Converts a number to an uppercase Roman numeral.
+ * @param value - The number to convert. Number must be an integer and `between 1 and 3999`.
+ * @returns The Roman numeral representation in uppercase.
+ *
+ * @example convertToRomanNumerals(29) // → "XXIX"
+ */
+declare const convertToRomanNumerals: (value: Numeric) => RomanCapital;
+/**
+ * * Converts a Roman numeral to its Arabic numeric representation.
+ * @param roman - The Roman numeral to convert. Case-insensitive but must represent a valid Roman numeral (`I`–`MMMCMXCIX`) otherwise throws runtime error.
+ * @returns The numeric (Arabic system) representation of the Roman numeral.
+ *
+ * @example
+ * romanToInteger("XXIX") // → 29
+ * romanToInteger("mmxxv") // → 2025
+ */
+declare const romanToInteger: (roman: LooseRomanNumeral) => number;
+/**
+ * * Converts a number, numeric string, or cardinal word string into its ordinal word representation.
+ *
+ * @param number - A number (e.g. `42`), numeric string (e.g. `"42"`), or cardinal word (e.g. `"forty-two"`).
+ * @returns The ordinal word form (always in lowercase) of the input.
+ *
+ * @example
+ * numberToWordsOrdinal(1); // "first"
+ * numberToWordsOrdinal("23"); // "twenty-third"
+ * numberToWordsOrdinal("twenty-three"); // "twenty-third"
+ */
+declare function numberToWordsOrdinal(number: Numeric | string): string;
+/**
+ * * Convert an English cardinal/ordinal word string into a number.
+ *
+ * - Accepts hyphenated words, "and", ordinals (first, second, etc.), negatives, and large scales (thousand, million etc.).
+ *
+ * @example
+ * wordsToNumber('forty-two') // 42
+ * wordsToNumber('one hundred and seven') // 107
+ * wordsToNumber('two thousand three hundred') // 2300
+ * wordsToNumber('twenty-first') // 21
+ * wordsToNumber('negative five') // -5
+ *
+ * @param word - A human readable number (cardinal or ordinal) in words
+ * @returns Numeric value of the word or NaN if cannot parse
+ *
+ * @remarks
+ * **NOTE** - *For very large numbers (e.g. more than quintillion) results may not always be correct.*
+ */
+declare function wordsToNumber(word: string): number;
+/**
+ * * Converts Bangla (Arabic system) digits to Latin (Arabic system) digits.
+ *
+ * @remarks
+ * - Behavior depends on the `forceNumber` flag:
+ *   - When `forceNumber` is `true`, always returns a `number` (strips non-digit characters).
+ * 	   - Returns `NaN` if the input is non empty string or does not include any numeric string.
+ *   - When `forceNumber` is `false`, always returns a string, including non-digit characters.
+ * 	   - Returns empty string if the input is non empty string.
+ *
+ * @param bnDigit - A string containing Bangla (Arabic system) digits.
+ * @param forceNumber - Whether to force number conversion even if the input includes non-digit character(s). Default is `false`.
+ *
+ * @example
+ * banglaToDigit('১২৩abc'); // 123
+ * banglaToDigit(''); // NaN
+ * banglaToDigit('৪৫৬');    // 456
+ *
+ * @example
+ * banglaToDigit('১২৩', false);	// "123"
+ * banglaToDigit('১২৩abc', false);	// "123abc"
+ */
+declare function banglaToDigit<Force extends boolean = true>(bnDigit: string, forceNumber?: Force): BnDigitResult<Force>;
+/**
+ * * Converts Latin (Arabic system) digits to Bangla digits (Arabic system).
+ *
+ * @remarks
+ * - Accepts numbers or numeric strings including non-digit characters.
+ * - When `preserveNonDigit` is `true`, non-digit characters are preserved in the output.
+ * - When `preserveNonDigit` is `false`, non-numeric strings are stripped.
+ * - Returns empty string for invalid input.
+ *
+ * @param digit - A number or string containing Latin (Arabic system) digits.
+ * @param preserveNonDigit - Whether to preserve non-digit characters in the output. Default is `true`.
+ *
+ * @example
+ * digitToBangla(123);          // "১২৩"
+ * digitToBangla('456');        // "৪৫৬"
+ *
+ * @example
+ * digitToBangla('12ab', false);	// "১২"
+ * digitToBangla('12ab');		// "১২ab"
+ */
+declare function digitToBangla(digit: number | string, preserveNonDigit?: boolean): string;
+//#endregion
+//#region src/number/prime.d.ts
+/**
+ * * Checks if a number is prime.
+ *
+ * @param number The number to check.
+ * @returns Boolean: `true` if the number is prime, otherwise `false`.
+ */
+declare const isPrime: (number: number) => boolean;
+/**
+ * * Find prime numbers in a given range.
+ *
+ * @param start The starting number of the range. Default is `1`.
+ * @param end The ending number of the range. Default is `1000`.
+ * @returns An array of prime numbers within the range (inclusive).
+ */
+declare const findPrimeNumbers: (start?: number, end?: number) => number[];
+//#endregion
+//#region src/number/utilities.d.ts
+/**
+ * * Rounds a number to the nearest specified interval.
+ * @param value - The number to round.
+ * @param interval - The interval to round to. Defaults to `5`.
+ * @returns The number rounded to the nearest interval.
+ * @example roundToNearest(27, 5) → 25
+ */
+declare const roundToNearest: (value: Numeric, interval?: number) => number;
+/**
+ * * Formats a number as a currency string.
+ * @param value - The number to format.
+ * @param currency - The currency code (default: `USD`).
+ * @param locale - The locale for formatting (default: matching currency locale).
+ * @returns A formatted currency string.
+ * @example formatCurrency(1234.56) → "$1,234.56"
+ * @example formatCurrency(1234.56, "USD") → "$1,234.56"
+ * @example formatCurrency(1234.56, "USD", "en-US") → "$1,234.56"
+ */
+declare const formatCurrency: (value: Numeric, currency?: CurrencyCode, locale?: LocaleCode) => string;
+/**
+ * * Clamps a number within a specified range.
+ * @param value - The number to clamp.
+ * @param min - The minimum allowed value.
+ * @param max - The maximum allowed value.
+ * @returns The clamped number.
+ * @example clampNumber(15, 10, 20) → 15
+ * @example clampNumber(5, 10, 20) → 10
+ * @example clampNumber(25, 10, 20) → 20
+ */
+declare const clampNumber: (value: number, min: number, max: number) => number;
+/**
+ * * Generates a random floating-point number within a range.
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @returns A random floating-point number between min and max.
+ * @example randomFloat(1.5, 3.5) → 2.84623
+ */
+declare const getRandomFloat: (min: Numeric, max: Numeric) => number;
+/**
+ * * Returns the ordinal suffix for a given number (e.g., 1 -> 'st', 2 -> 'nd', 3 -> 'rd', 4 -> 'th' etc.).
+ * @description The function handles special cases for 11, 12, and 13, which all use 'th' despite the last digit.
+ * If the `withNumber` parameter is `true`, the function returns the number along with its ordinal suffix (e.g., "1st").
+ * Otherwise, it returns only the ordinal suffix (e.g., "st").
+ *
+ * @param num - The number or number string to get the ordinal suffix for.
+ * @param withNumber - Whether to include the number along with its ordinal suffix (defaults to `true`).
+ * @returns The appropriate ordinal suffix, optionally with the number (e.g., '1st' or 'st`, '2nd' or 'nd' and so on.).
+ */
+declare const getOrdinal: (num: Numeric, withNumber?: boolean) => string;
+/**
+ * * Normalize a number or numeric string to a number.
+ * @description
+ * This function checks if the input is a number or a numeric string and converts it to a number.
+ * If the input is not a valid number or numeric string, it returns `undefined`.
+ * @param num - The number to normalize.
+ * @returns The normalized number or `undefined` if the input is not a valid number or numeric string.
+ */
+declare function normalizeNumber(num: unknown): Maybe<number>;
+//#endregion
+//#region src/number/range.d.ts
+/**
+ * * Function to get numbers within a range based on the provided {@link NumberType} and options.
+ *
+ * @remarks Returns either string or array of numbers based on the {@link RangeOptions.getAsString getAsString} option.
+ *
+ * @param type - The type of numbers to generate ('random', 'prime', etc.).
+ * @param options - Options to configure number generation, including range and formatting.
+ * @returns The numbers in the range based on {@link type} and {@link options} either as string or array of numbers.
+ */
+declare function getNumbersInRange<T extends boolean = false>(type?: NumberType, options?: RangeOptions<T>): RangedNumbers<T>;
+//#endregion
+//#region src/array/basics.d.ts
+/**
+ * * Flattens a nested array recursively or wraps any non-array data type in an array.
+ *
+ * @param input - The input value, which can be a nested array or a non-array value.
+ * @returns A fully flattened array of type `Flatten<T>`. If the input is not an array, it wraps it in a single-element array.
+ */
+declare const flattenArray: <T>(input: T | T[]) => Flattened<T>[];
+/**
+ * @deprecated _Please, use `findAll` instance method from `Finder` class for **more advanced filtering and searching.**_
+ *
+ * * Filters an array of objects based on multiple conditions for specified keys.
+ * @param array - The array of objects to filter.
+ * @param conditions - An object where keys represent the property names and values represent filter conditions.
+ *                     The conditions can be a function `(value: T[K]) => boolean`.
+ * @returns The filtered array of objects.
+ * @throws `Error` If the input is not a valid array.
+ */
+declare const filterArrayOfObjects: <T extends GenericObject>(array: T[], conditions: { [K in keyof T]?: (value: Maybe<T[K]>) => boolean }) => T[];
+/**
+ * * Checks if a value is an empty array or an array with only empty values.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is not an array, an empty array, or an array containing only `null`, `undefined`, empty objects, or empty arrays.
+ */
+declare const isInvalidOrEmptyArray: <T>(value: T) => boolean;
+/**
+ * * Shuffle the elements of an array.
+ *
+ * @param array Array to shuffle.
+ * @returns Shuffled array.
+ */
+declare const shuffleArray: <T>(array: T[]) => T[];
+/**
+ * * Get the last element of an array.
+ *
+ * @param array Array to get the last element from.
+ * @returns The last element or `undefined` if the array is empty.
+ */
+declare const getLastArrayElement: <T>(array: T[]) => Maybe<T>;
+//#endregion
+//#region src/array/calc.d.ts
+/**
+ * * Calculates the sum of differences between two numeric fields for each item in the array.
+ *
+ * @param data - The array of objects to process.
+ * @param first - The field name to subtract **from** (minuend), supports nested dot notation.
+ * @param second - The field name to subtract (subtrahend), supports nested dot notation.
+ * @param roundTo - Decimal places to round the result to. Defaults to 2.
+ * @returns The total sum of differences between the two fields across all items.
+ *
+ * @example
+ * sumFieldDifference([{ buy: 10, sell: 3 }, { buy: 8, sell: 5 }], 'buy', 'sell');
+ * // => 10
+ */
+declare function sumFieldDifference<T extends GenericObject, P extends NumericDotKey<T>>(data: Maybe<T[]>, first: P, second: P, roundTo?: number): number;
+/**
+ * * Calculates the total sum of a numeric field across all items.
+ *
+ * @param data - The array of objects to process.
+ * @param field - The field to sum values from. Supports nested dot notation.
+ * @param roundTo - Decimal places to round the result to. Defaults to 2.
+ * @returns The rounded total sum.
+ *
+ * @example
+ * sumByField([{ a: 5 }, { a: 3 }], 'a');
+ * // => 8
+ */
+declare function sumByField<T extends GenericObject>(data: Maybe<T[]>, field: NumericDotKey<T>, roundTo?: number): number;
+/**
+ * * Calculates the average of a numeric field across all items.
+ *
+ * @param data - The array of objects to process.
+ * @param field - The field to calculate the average from. Supports nested dot notation.
+ * @param roundTo - Decimal places to round the result to. Defaults to 2.
+ * @returns The rounded average.
+ *
+ * @example
+ * averageByField([{ a: 4 }, { a: 6 }], 'a');
+ * // => 5
+ */
+declare function averageByField<T extends GenericObject>(data: Maybe<T[]>, field: NumericDotKey<T>, roundTo?: number): number;
+/**
+ * * Groups an array of objects by a primitive field and sums another numeric field per group.
+ *
+ * @param data - The array of objects to group.
+ * @param groupBy - The field to group by. Supports nested dot notation.
+ * @param sumBy - The numeric field to sum within each group. Supports nested dot notation.
+ * @param roundTo - Decimal places to round each group’s result to. Defaults to 2.
+ * @returns An array of records, each with the group key and its corresponding summed value.
+ *
+ * @example
+ * groupAndSumByField([{ type: 'A', val: 2 }, { type: 'A', val: 3 }, { type: 'B', val: 1 }], 'type', 'val');
+ * // => [{ A: 5 }, { B: 1 }]
+ */
+declare function groupAndSumByField<T extends GenericObject>(data: Maybe<T[]>, groupBy: NestedPrimitiveKey<T>, sumBy: NumericDotKey<T>, roundTo?: number): Array<Record<string, number>>;
+/**
+ * * Groups an array of objects by a primitive field and averages another numeric field per group.
+ *
+ * @param data - The array of objects to group.
+ * @param groupBy - The field to group by. Supports nested dot notation.
+ * @param averageBy - The numeric field to average within each group. Supports nested dot notation.
+ * @param roundTo - Decimal places to round each group’s average to. Defaults to 2.
+ * @returns An array of records, each with the group key and its corresponding average value.
+ *
+ * @example
+ * groupAndAverageByField([{ type: 'A', val: 2 }, { type: 'A', val: 4 }, { type: 'B', val: 6 }], 'type', 'val');
+ * // => [{ A: 3 }, { B: 6 }]
+ */
+declare function groupAndAverageByField<T extends GenericObject>(data: Maybe<T[]>, groupBy: NestedPrimitiveKey<T>, averageBy: NumericDotKey<T>, roundTo?: number): Array<Record<string, number>>;
+//#endregion
+//#region src/array/Finder.d.ts
+type KeySelector<T> = Extract<OwnKeys<T>, string | number> | ((item: T) => string | number);
+/**
+ * @class `Finder` performs optimized searching on arrays.
+ *      - It supports binary search, fuzzy search, and smart caching with TTL.
+ */
+declare class Finder<T extends GenericObject> {
+  #private;
+  /**
+   * * Creates a new `Finder` instance with a static array of items.
+   *
+   * @param data An array of items to initialize the search dataset.
+   * @param ttl Optional time-to-live (in milliseconds) for cached search results. Defaults to {@link Finder.#DEFAULT_TTL 5 Minutes}.
+   */
+  constructor(data: T[], ttl?: number);
+  /**
+   * * Creates a new `Finder` instance with a lazy-evaluated item provider.
+   *
+   * @param cb A function returning an array of items to initialize the search dataset.
+   * @param ttl Time-to-live (in milliseconds) for cached search results. Defaults to {@link Finder.#DEFAULT_TTL 5 Minutes}.
+   */
+  constructor(cb: () => T[], ttl?: number);
+  /**
+   * @instance Clears cache globally or for a specific key.
+   * @param key Optional key to clear only a specific cache entry.
+   */
+  clearCache(key?: string): void;
+  /**
+   * @instance Finds all items that match the provided matcher using optional caching or fuzzy logic.
+   * @param matcher The value to match against.
+   * @param keySelector Property key or selector function.
+   * @param options Optional settings for search behavior and source list.
+   */
+  findAll(matcher: string | number, keySelector: KeySelector<T>, options?: FindOptions<T>): T[];
+  /**
+   * @instance Finds first matching item that matches the provided matcher using optional caching or fuzzy logic.
+   * @param matcher The value to match.
+   * @param keySelector Property key or selector function.
+   * @param options Optional behavior flags and item source.
+   */
+  findOne(matcher: string | number, keySelector: KeySelector<T>, options?: FindOptions<T>): Maybe<T>;
+  /**
+   * @instance Asynchronous variant of `findAll` that accepts a promise-based data supplier.
+   * @param supplier Async function resolving the items list.
+   * @param matcher The value to match.
+   * @param keySelector Property key or selector function.
+   * @param options Optional settings for search behavior and cache.
+   */
+  findAllAsync(supplier: () => Promise<T[]>, matcher: string | number, keySelector: KeySelector<T>, options?: Omit<FindOptions<T>, 'data'>): Promise<T[]>;
+  /**
+   * @instance Asynchronous variant of `findOne`.
+   * @param supplier Async function resolving the items list.
+   * @param matcher The value to match.
+   * @param keySelector Property key or selector function.
+   * @param options Optional settings for behavior and cache.
+   */
+  findOneAsync(supplier: () => Promise<T[]>, matcher: string | number, keySelector: KeySelector<T>, options?: Omit<FindOptions<T>, 'data'>): Promise<Maybe<T>>;
+  /**
+   * @instance Performs a binary search on a sorted array using a custom key selector.
+   *
+   * @param sorted - The sorted array of items to search.
+   * @param matcher - The value to search for.
+   * @param keySelector - A function that extracts the comparable key from each item.
+   * @param caseInsensitive - Whether to compare string keys ignoring case.
+   * @returns The first matching item if found; otherwise, undefined.
+   */
+  binarySearch(sorted: T[], matcher: string | number, keySelector: (item: T) => string | number, caseInsensitive: boolean): Maybe<T>;
+  /**
+   * @instance Performs a fuzzy search on an array by matching characters in sequence.
+   *
+   * @param array - The array of items to search.
+   * @param matcher - The fuzzy search string to match against.
+   * @param keySelector - A function that extracts the key to search from each item.
+   * @param caseInsensitive - Whether to compare ignoring case for string values.
+   * @returns The first fuzzy-matching item if found; otherwise, undefined.
+   */
+  fuzzySearch(array: T[], matcher: string, keySelector: (item: T) => string | number, caseInsensitive: boolean): Maybe<T>;
+}
+//#endregion
+//#region src/array/sort.d.ts
+/**
+ * Compare two strings using natural sorting (e.g., `"file2"` < `"file10"`).
+ * - Optionally supports case-insensitive and locale-aware string chunk comparisons.
+ *
+ * @param a - The first string to compare.
+ * @param b - The second string to compare.
+ * @param options - Optional settings to configure comparison behavior.
+ * @returns A negative number if `a` comes before `b`, a positive number if `a` comes after `b`, or 0 if equal.
+ */
+declare function naturalSort(a: string, b: string, options?: SortNature): number;
+/**
+ * * Sorts an array of objects based on the provided options.
+ *
+ * @remarks
+ * - Sorts array by the specified field in the options `sortByField`.
+ * - Uses {@link naturalSort} for sorting string values.
+ *
+ * @param array - The array of objects to sort.
+ * @param options - Sorting options for objects.
+ * @returns The sorted array.
+ */
+declare function sortAnArray<T extends GenericObject>(array: T[], options: SortByOption<T>): T[];
+/**
+ * * Sorts an array of `strings`, `numbers` or `boolean` based on the provided options.
+ *
+ * @remarks
+ * - If the array contains strings, it sorts them alphabetically.
+ * - If the array contains numbers, it sorts them numerically.
+ * - If the array contains booleans, it sorts them by their boolean value.
+ * - Uses {@link naturalSort} for sorting string values.
+ *
+ * @param array - The array of `strings`, `numbers` or `boolean` to sort.
+ * @param options - Sorting options.
+ * @returns  The sorted array.
+ */
+declare function sortAnArray<T extends BasicPrimitive>(array: T[], options?: OrderOption): T[];
+//#endregion
+//#region src/array/transform.d.ts
+/**
+ * * Converts an array of objects into a formatted array of options.
+ *
+ * @param data - An array of objects to convert into options.
+ * @param config - The configuration object to specify the keys for the `value` (firstFieldName) and `label` (secondFieldName) fields and rename as needed.
+ * @returns An array of options, where each option has `value` and `label` fields as default or as specified by user in the config options.
+ */
+declare function createOptionsArray<T extends GenericObject, K1 extends string = 'value', K2 extends string = 'label', V extends boolean = false>(data: T[], config: OptionsConfig<T, K1, K2, V>): Array<{ [P in K1 | K2]: FieldValue<P, T, K1, K2, V> }>;
+/**
+ * * Removes duplicate values from an array, supporting deep comparison for objects and arrays.
+ *
+ * @param array - The array from which duplicates need to be removed.
+ * @returns A new array with duplicates removed.
+ */
+declare function removeDuplicatesFromArray<T>(array: T[]): T[];
+/**
+ * * Finds duplicate values in an array, runs deep comparison for objects and arrays.
+ *
+ * @param array - The array in which to find duplicates.
+ * @returns An array containing all duplicate entries (each one only once).
+ */
+declare function getDuplicates<T>(array: T[]): T[];
+/**
+ * * Finds elements missing from one array compared to another using deep comparison.
+ *
+ * @param options - Configuration to specify which array to compare and direction of check.
+ * @returns An array of missing elements based on the comparison direction.
+ */
+/**
+ * * Finds elements missing from one array compared to another using deep comparison.
+ *
+ * @param array1 The first array to compare.
+ * @param array2 The second array to compare.
+ * @param missingFrom Which direction to compare for missing values:.
+ *					  - `'from-first'` → values in `array1` missing in `array2`.
+ *					  - `'from-second'` → values in `array2` missing in `array1`.
+ * @returns An array of missing elements based on the comparison direction.
+ */
+declare function findMissingElements<T, U>(array1: T[], array2: U[], missingFrom: 'from-first' | 'from-second'): (T | U)[];
+/**
+ * * Splits an array into chunks of a given size.
+ *
+ * @param arr The array to split.
+ * @param chunkSize The size of each chunk.
+ * @returns An array of chunked arrays.
+ */
+declare function splitArray<T>(arr: T[], chunkSize: number): Array<T[]>;
+/**
+ * * Group an array of objects by a specified key, returning only arrays of grouped objects.
+ *
+ * @param source - The source array of objects to group.
+ * @param property - The property to group the array by. Property can be a string, number, boolean, undefined or null. Supports nested dot notation.
+ *
+ * @returns An array of grouped arrays. Each sub-array contains objects that share the same value for the specified property.
+ *
+ * @example
+ * splitArrayByProperty([{ type: 'a' }, { type: 'b' }, { type: 'a' }, { type: undefined }], 'type')
+ * // => [ [{ type: 'a' }, { type: 'a' }], [{ type: 'b' }], [{ type: undefined }] ]
+ *
+ * @notes
+ * - Returns an empty array if the input is invalid or empty.
+ * - Groups objects even when the group key is `undefined` or `null` (object with `null` & `undefined` property-values are grouped together).
+ */
+declare function splitArrayByProperty<T extends GenericObject, P extends NestedPrimitiveKey<T>>(source: Maybe<T[]>, property: P): Array<T[]>;
+/**
+ * * Rotates an array left or right by a given number of steps.
+ *
+ * @param arr The array to rotate.
+ * @param steps The number of positions to rotate (positive: right, negative: left).
+ * @returns The rotated array.
+ */
+declare function rotateArray<T>(arr: T[], steps: number): T[];
+/**
+ * * Moves an element within an array from one index to another.
+ *
+ * @param arr The array to modify.
+ * @param fromIndex The index of the element to move.
+ * @param toIndex The new index for the element.
+ * @returns A new array with the element moved.
+ */
+declare function moveArrayElement<T>(arr: T[], fromIndex: number, toIndex: number): T[];
+//#endregion
+//#region src/object/basics.d.ts
+/**
+ * * Deep clone an object using `structuredClone` or deterministic *JSON serialization*.
+ *
+ * @param obj Object to clone.
+ * @param serialize Whether to force deterministic JSON serialization instead of using `structuredClone`. Defaults to `false`.
+ * @returns Deep cloned object.
+ *
+ * @remarks
+ * **Primary behavior**
+ * - By default (`serialize = false`), the function uses {@link https://developer.mozilla.org/docs/Web/API/Window/structuredClone structuredClone} when available. This supports:
+ *   - Circular references
+ *   - `Date` objects
+ *   - `Map` / `Set`
+ *   - `RegExp`
+ *   - Typed arrays
+ *   - Most built-in JavaScript types
+ *   - Preserves `undefined` values
+ *
+ * - **Note:** `structuredClone` **does not preserve class prototypes**, even though it preserves data types like `Date`, `Map`, and `Set`.
+ *
+ * **Deterministic serialization mode**
+ * - When `serialize = true`, or when `structuredClone` is unavailable, the function falls back to **stable JSON serialization** via `stableStringify`. This guarantees:
+ *   - All object keys are sorted alphabetically.
+ *   - Consistent output across environments (deterministic).
+ *   - All `undefined` values are converted to `null`.
+ *   - Converting date-like objects (`Date`, `Chronos`, `Moment.js`, `Day.js`, `Luxon`, `JS-Joda`, `Temporal`) **in the same way that {@link JSON.stringify} would serialize them**, ensuring predictable and JSON-compliant output.
+ *
+ * - This mode is ideal for:
+ *   - Hashing
+ *   - Signature generation
+ *   - Deep equality checks
+ *   - Anything requiring deterministic, environment-neutral output
+ *
+ * **Deterministic mode limitations**
+ * - JSON serialization will:
+ *   - Drop functions and `Symbol` values.
+ *   - Lose prototype and class instance information.
+ *   - Convert all date-like objects into strings.
+ *   - Fail on circular references.
+ *
+ * **Final safety fallback**
+ * - If JSON serialization fails (e.g., due to circular references), the function returns a **shallow clone** (`{ ...obj }`) to ensure the cloning never throws.
+ */
+declare function cloneObject<T extends GenericObject>(obj: T, serialize?: boolean): T;
+/**
+ * * Count the number of fields in an object.
+ *
+ * @param obj Object to check.
+ * @returns Number of fields in the object.
+ */
+declare function countObjectFields<T extends GenericObject>(obj: T): number;
+/**
+ * * Extracts all the top-level keys of an object as an array.
+ *
+ * @remarks
+ * - Returns a normal array of keys (string literals).
+ * - Safe for runtime iteration.
+ * - Returns an empty array (`[]`) for empty or non-object values.
+ *
+ * @param obj The object from which to extract keys.
+ * @returns Array of keys.
+ *
+ * @example
+ * const keys = extractObjectKeys({ a: 1, b: 2 });
+ * // keys: ["a", "b"]; typed as ("a" | "b")[]
+ */
+declare function extractObjectKeys<T extends GenericObject>(obj: T): Array<keyof T>;
+/**
+ * * Extracts all the top-level keys of an object as a tuple.
+ *
+ * @remarks
+ * - Returns a typed tuple based on the input type, not runtime values.
+ * - **Caution:** The order of keys in the returned tuple is determined by TypeScript’s type system and **may not match the runtime order** returned by `Object.keys(obj)`.
+ * - Use this tuple for strict type-level operations, not for runtime iteration that relies on key order.
+ * - Useful when you want literal type information preserved.
+ * - Returns an empty tuple (`[]`) for empty or non-object values.
+ *
+ * @param obj The object from which to extract keys.
+ * @param tuple Pass `true` to return as tuple instead of an array type.
+ * @returns Tuple of keys.
+ *
+ * @example
+ * const keysTuple = extractObjectKeys({ a: 1, b: 2 }, true);
+ * // keysTuple: ["a", "b"]; also typed as ["a", "b"]
+ */
+declare function extractObjectKeys<T extends GenericObject>(obj: T, tuple: true): Tuple<keyof T>;
+/**
+ * * Recursively extracts all nested keys from an object as an array.
+ *
+ * @remarks
+ * - Returns an empty array (`[]`) for an empty object or a non-object value.
+ * - For only top-level keys, use {@link extractObjectKeys}.
+ *
+ * @param obj The object from which to extract the keys.
+ * @returns An array of all the nested keys (string literals) from the specified object.
+ */
+declare function extractObjectKeysDeep<T extends GenericObject>(obj: T): Array<DeepKeys<T>>;
+//#endregion
+//#region src/object/objectify.d.ts
+/**
+ * Deeply merges two or more objects.
+ * Objects are merged recursively. Later values override earlier ones unless both are plain objects.
+ *
+ * @param objects - List of objects to be merged.
+ * @returns A new object with deeply merged properties from all input objects.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { x: 10 } };
+ * const obj2 = { b: { y: 20 }, c: 3 };
+ * const merged = mergeObjects(obj1, obj2);
+ * // merged = { a: 1, b: { x: 10, y: 20 }, c: 3 }
+ *
+ * @example
+ * mergeObjects(
+ *   { a: 1, b: 2 },
+ *   { p: { c: 3 }, d: 4 },
+ *   { p: { e: 5 }, f: 6 }
+ * );
+ * // => { a: 1, b: 2, p: { c: 3, e: 5 }, d: 4, f: 6 }
+ */
+declare const mergeObjects: <T extends Objects>(...objects: T) => ExpandAll<MergeAll<T>>;
+/**
+ * * Deeply merge objects and flatten nested objects.
+ * * Useful for flattening a single object or merging multiple objects with duplicate key(s).
+ * * If keys are duplicated, the last object's value will be used.
+ *
+ * @param objects Objects to merge.
+ * @returns Merged object with flattened structure.
+ */
+declare const mergeAndFlattenObjects: <T extends Objects>(...objects: T) => ExpandAll<FlattenDotValue<MergeAll<T>>>;
+/**
+ * * Flattens a nested object into key-value format.
+ *
+ * @param object - The `object` to flatten.
+ * @returns A `flattened object` in key-value format.
+ */
+declare const flattenObjectKeyValue: <T extends GenericObject>(object: T) => ExpandAll<FlattenLeafValue<MergeAll<[T]>>>;
+/**
+ * * Flattens a nested object into a dot notation format.
+ *
+ * @param object - The `object` to flatten.
+ * @returns A `flattened object` with dot notation keys.
+ */
+declare const flattenObjectDotNotation: <T extends GenericObject>(object: T) => ExpandAll<FlattenDotValue<MergeAll<[T]>>>;
+/**
+ * * Extracts only the fields that have changed between the original and updated object.
+ *
+ * @param baseObject The original object to compare against.
+ * @param updatedObject The modified object containing potential updates.
+ * @returns A new object containing only the changed fields.
+ */
+declare const extractUpdatedFields: <T extends GenericObject>(baseObject: T, updatedObject: FlattenPartial<T>) => FlattenPartial<T>;
+/**
+ * * Extracts only new fields that exist in updatedObject but not in baseObject.
+ *
+ * @param baseObject The original object to compare against.
+ * @param updatedObject The modified object containing potential new fields.
+ * @returns A new object containing only the new fields.
+ */
+declare const extractNewFields: <T extends GenericObject, U extends GenericObject>(baseObject: T, updatedObject: FlattenPartial<T> & FlattenPartial<U>) => FlattenPartial<U>;
+/**
+ * * Extracts changed fields from the updated object while also identifying newly added keys.
+ *
+ * @param baseObject The original object to compare against.
+ * @param updatedObject The modified object containing potential updates.
+ * @returns An object containing modified fields and new fields separately.
+ */
+declare const extractUpdatedAndNewFields: <T extends GenericObject, U extends GenericObject>(baseObject: T, updatedObject: FlattenPartial<T> & FlattenPartial<U>) => FlattenPartial<T> & FlattenPartial<U>;
+/**
+ * * Safely parses a JSON string into an object.
+ * * Optionally converts stringified primitive values inside the object (e.g., `"0"` → `0`, `"true"` → `true`, `"null"` → `null`).
+ *
+ * @param value - The JSON string to parse.
+ * @param parsePrimitives - Whether to convert stringified primitives into real values (default: `true`).
+ * @returns A parsed object with primitive conversions, or an empty object on failure or if the root is not a valid object.
+ * - Returns `{}` if parsing fails, such as when the input is malformed or invalid JSON or passing single quoted string.
+ *
+ * - **N.B.** This function will return an empty object if the JSON string is invalid or if the root element is not an object.
+ *
+ * - *Unlike `parseJSON`, which returns any valid JSON structure (including arrays, strings, numbers, etc.),
+ * this function strictly ensures that the result is an object and optionally transforms stringified primitives.*
+ *
+ * @see parseJSON - For parsing generic JSON values (arrays, numbers, etc.) with optional primitive transformation.
+ *
+ */
+declare const parseJsonToObject: <T extends GenericObject = GenericObject>(value: string, parsePrimitives?: boolean) => T;
+//#endregion
+//#region src/object/sanitize.d.ts
+/**
+ * * Trims all the words in a string.
+ *
+ * @param input String to sanitize.
+ * @returns Sanitized string .
+ */
+declare function sanitizeData(input: string): string;
+/**
+ * * Trims all the words in an array of strings.
+ *
+ * @param input Array of strings to sanitize.
+ * @returns Sanitized array of strings.
+ */
+declare function sanitizeData(input: string[]): string[];
+/**
+ * * Sanitizes a deeply nested array that may contain arrays, objects or other (mixed) data types.
+ * * Preserves structure while removing empty values and trimming strings and other operations.
+ *
+ * @param array - An array of objects that may contain arrays, objects or other data types.
+ * @param options - Options that define which keys to ignore, whether to trim string values, and whether to exclude nullish, falsy or empty values.
+ * @param _return - By default return type is as it is, passing this parameter `partial` makes the return type `$DeepPartial<T>`.
+ * @returns A new sanitized array with the specified modifications.
+ */
+declare function sanitizeData<Data extends GenericObject, Ignored extends DotNotationKey<Data> = never, PoR extends PartialOrRequired = 'required'>(array: Data[], options?: SanitizeOptions<Data, Ignored>, _return?: PoR): Array<SanitizedData<Data, Ignored, PoR>>;
+/**
+ * * Sanitizes an object by ignoring specified keys and trimming string values based on options provided.
+ * * Also excludes nullish values (`null`, `undefined`), falsy (`nullish` + `0` & `""`) or empty values (`object`, `array`) if specified.
+ *
+ * @param object - The object to sanitize.
+ * @param options - Options that define which keys to ignore, whether to trim string values, and whether to exclude nullish, falsy or empty values.
+ * @param _return - By default return type is as it is, passing this parameter `true` makes the return type `Partial<T>`.
+ * @returns A new object with the specified modifications.
+ */
+declare function sanitizeData<Data extends GenericObject, Ignored extends DotNotationKey<Data> = never, PoR extends PartialOrRequired = 'required'>(object: Data, options?: SanitizeOptions<Data, Ignored>, _return?: PoR): SanitizedData<Data, Ignored, PoR>;
+/**
+ * * Parse an object of stringified values into their appropriate primitive types.
+ *
+ * @description
+ * - Attempts to convert string values into `boolean`, `number`, or JSON-parsed objects/arrays.
+ * - Non-string values except arrays/objects are left unchanged. Nested arrays/objects are parsed recursively.
+ *
+ * @param object - The object with potentially stringified primitive values.
+ * @param parseNested - Whether to convert stringified primitives in nested arrays/objects. (default: `true`).
+ * @returns A new object with parsed values converted to their original types.
+ */
+declare function parseObjectValues<T extends GenericObject>(object: T, parseNested?: boolean): { [K in keyof T]: Any };
+//#endregion
+//#region src/object/convert.d.ts
+/**
+ * * Converts the values of specified keys in an object to `"string"` or `"number"`.
+ * * Supports nested objects using dot-notation keys.
+ *
+ * @param data The object to convert.
+ * @param options Options object specifying the conversion mapping.
+ *   - `keys`: The keys in the objects to be converted (dot-notation supported).
+ *   - `convertTo`: The target type, either `"string"` or `"number"`.
+ * @returns The modified object with the converted values as `"string"` or `"number"`.
+ */
+declare function convertObjectValues<T extends GenericObject, Key extends NumericDotKey<T>, C extends 'string' | 'number'>(data: T, options: ConvertObjectOptions<T, Key, C>): ConvertedObject<T, Key, C>;
+/**
+ * * Converts the values of specified keys in an array of objects to `"string"` or `"number"`.
+ * * Supports nested objects using dot-notation keys.
+ *
+ * @param data The array of objects to convert.
+ * @param options Options object specifying the conversion mapping.
+ *   - `keys`: The keys in the objects to be converted (dot-notation supported).
+ *   - `convertTo`: The target type, either `"string"` or `"number"`.
+ * @returns The modified array of objects with the converted values as `"string"` or `"number"`.
+ */
+declare function convertObjectValues<T extends GenericObject, Key extends NumericDotKey<T>, C extends 'string' | 'number'>(data: Array<T>, options: ConvertObjectOptions<T, Key, C>): Array<ConvertedObject<T, Key, C>>;
+/**
+ * * Pick specific fields from an object and create a new object with specified fields.
+ *
+ * @description This function creates a new object containing only the specified fields from the source object.
+ * It is useful for creating a new object with a subset of properties from an existing object.
+ *
+ * @param T The type of the source object.
+ * @param U The type of the keys to pick from the source object.
+ *
+ * @param source The source object from which to pick fields.
+ * @param keys The keys of the fields to pick from the source object.
+ *
+ * @returns An object containing only the picked fields.
+ */
+declare function pickFields<T extends GenericObject, U extends keyof T>(source: T, keys: U[]): { [K in U]: T[K] };
+/**
+ * * Create a new object by removing specific keys from the source object.
+ *
+ * @param source - The original (source) object from which to delete fields.
+ * @param keys - An array of keys (fields) to remove from the object.
+ *
+ * @returns A new object without the specified keys.
+ *
+ * @example
+ * deleteFields({ a: 1, b: 2, c: 3 }, ['b'])
+ * // => { a: 1, c: 3 }
+ *
+ * @notes
+ * - Does not mutate the original object.
+ * - Useful for excluding sensitive or unwanted fields.
+ */
+declare function deleteFields<T extends GenericObject, U extends keyof T>(source: T, keys: readonly U[]): { [K in Exclude<keyof T, U>]: T[K] };
+/**
+ * * Pick specific fields from an object based on a given condition.
+ *
+ * @description This function creates a new object containing only the fields that satisfy the given condition.
+ * The condition can be based on the field's value or type, depending on the implementation.
+ *
+ * @param T The type of the source object.
+ *
+ * @param source The source object from which to pick fields.
+ * @param condition A function that takes the key and value of a property and returns a boolean indicating whether the property should be picked.
+ *
+ * @returns An object containing only the fields that satisfy the condition.
+ */
+declare function pickObjectFieldsByCondition<T extends GenericObject>(source: T, condition: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>;
+/**
+ * * Remap fields from one object to another.
+ * @description This function creates a new object with fields remapped from the source object to the target object based on the provided field map.
+ *
+ * @param source The source object from which to remap fields.
+ * @param fieldMap  An object that maps target keys to source keys.
+ * @returns An object with fields remapped according to the field map.
+ */
+declare function remapFields<Source extends GenericObject, Target extends Record<string, keyof Source>>(source: Source, fieldMap: Target): { [K in keyof Target]: Source[Target[K]] };
+//#endregion
+//#region src/utils/index.d.ts
+/**
+ * * Deeply compare two values (arrays, objects, or primitive values).
+ *
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns Whether the values are deeply equal.
+ */
+declare const isDeepEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * * Converts an array of objects to a string using a specific property (supports nested path to primitive values) and separator.
+ *
+ * @example
+ * const users = [
+ * 	{ id: 1, name: { first: 'Alice' }, city: 'Bangu', },
+ * 	{ id: 4, name: { first: 'Bob' }, city: 'Banguland', },
+ * ];
+ * convertArrayToString(users, { target: 'name.first', separator: ' | ' });
+ * // "Alice | Bob"
+ *
+ * @param array Array of objects to convert.
+ * @param options Options including the target property and separator.
+ * @returns String formed by joining the property values with the given separator.
+ */
+declare function convertArrayToString<T extends GenericObject>(array: Maybe<T[]>, options: ArrayOfObjectsToStringOptions<T>): string;
+/**
+ * * Converts an array of primitive values to a string using a custom separator.
+ *
+ * @example
+ * convertArrayToString(['red', 'green', 'blue'], { separator: ' - ' });
+ * // "red - green - blue"
+ *
+ * @example
+ * convertArrayToString([1, 2, 3]);
+ * // "1, 2, 3"
+ *
+ * @param array Array of primitive values to convert.
+ * @param options Optional separator configuration.
+ * @returns String formed by joining array elements with the given separator.
+ */
+declare function convertArrayToString<T extends Primitive>(array: Maybe<T[]>, options?: ArrayOfPrimitivesToStringOptions): string;
+/**
+ * * A generic debounce function that delays the execution of a callback.
+ *
+ * @param callback - The function to debounce.
+ * @param delay - The delay in milliseconds. Default is `300ms`.
+ * @returns A debounced version of the callback function.
+ *
+ * @example
+ * const debouncedSearch = debounceAction((query: string) => {
+ *   console.log(`Searching for: ${query}`);
+ * }, 300);
+ *
+ * debouncedSearch('laptop'); // Executes after 300ms of inactivity.
+ */
+declare function debounceAction<T extends VoidFn>(callback: T, delay?: number): DelayedFn<T>;
+/**
+ * * A generic throttle function that ensures a callback is executed at most once per specified interval.
+ *
+ * @param callback - The function to throttle.
+ * @param delay - The delay in milliseconds. Default is `150ms`.
+ * @returns A throttled version of the callback function.
+ *
+ * @example
+ * const throttledResize = throttleAction(() => {
+ *   console.log('Resized');
+ * }, 300);
+ *
+ * window.addEventListener('resize', throttledResize);
+ */
+declare function throttleAction<T extends VoidFn>(callback: T, delay?: number): DelayedFn<T>;
+/**
+ * * Retrieves the names of all instance methods defined directly on a class prototype.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns A sorted array of instance method names.
+ */
+declare function getInstanceMethodNames(cls: Constructor): string[];
+/**
+ * * Retrieves the names of all static methods defined directly on a class constructor.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns A sorted array of static method names.
+ */
+declare function getStaticMethodNames(cls: Constructor): string[];
+/**
+ * * Counts the number of instance methods defined directly on a class prototype.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns The number of instance methods defined on the class prototype.
+ */
+declare function countInstanceMethods(cls: Constructor): number;
+/**
+ * * Counts the number of static methods defined directly on a class constructor.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns The number of static methods defined on the class constructor.
+ */
+declare function countStaticMethods(cls: Constructor): number;
+/**
+ * * Retrieves the names of all instance getters defined directly on a class prototype.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns A sorted array of instance getter names.
+ */
+declare function getInstanceGetterNames(cls: Constructor): string[];
+/**
+ * * Retrieves the names of all static getters defined directly on a class constructor.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns A sorted array of static getter names.
+ */
+declare function getStaticGetterNames(cls: Constructor): string[];
+/**
+ * * Gathers detailed information about the instance and static methods of a class.
+ *
+ * @param cls - The class constructor (not an instance).
+ * @returns An object containing names and counts of instance and static methods.
+ */
+declare function getClassDetails(cls: Constructor): ClassDetails;
+/**
+ * * Create a deterministic JSON string representation of any value.
+ *   - The output format matches standard JSON but with guaranteed sorted keys.
+ *
+ * @remarks
+ * - This function guarantees **stable, repeatable output** by:
+ * 	 - Sorting all object keys alphabetically.
+ * 	 - Recursively stabilizing nested objects and arrays.
+ * 	 - Converting all `undefined` values into `null` so the output remains valid JSON.
+ *   - Converting date-like objects (`Date`, `Chronos`, `Moment.js`, `Day.js`, `Luxon`, `JS-Joda`, `Temporal`) **in the same way that {@link JSON.stringify} would serialize them**, ensuring predictable and JSON-compliant output.
+ *   - Falling back to native JSON serialization for primitives.
+ *
+ * - **Useful for:**
+ *   - Hash generation (e.g., signatures, cache keys)
+ *   - Deep equality checks
+ *   - Producing predictable output across environments
+ *
+ * @param obj - The value to stringify into a deterministic JSON string.
+ * @returns A stable, deterministic string representation of the input.
+ */
+declare function stableStringify(obj: unknown): string;
+/**
+ * * Remove trailing or leading garbage characters **after/before JSON object or array**.
+ * @param str String to sanitize/strip.
+ * @returns Sanitized/stripped JSON string.
+ */
+declare function stripJsonEdgeGarbage(str: string): string;
+/**
+ * * Parses any valid JSON string, optionally converting stringified primitives inside (nested) arrays or objects.
+ *
+ * @typeParam T - Expected return type (default is unknown).
+ * @param value - The JSON string to parse.
+ * @param parsePrimitives - Whether to convert stringified primitives (default: `true`).
+ * @returns The parsed JSON value typed as `T`, or the original parsed value with optional primitive conversion.
+ * - Returns `{}` if parsing fails, such as when the input is malformed or invalid JSON or passing single quoted string.
+ *
+ * - *Unlike {@link https://toolbox.nazmul-nhb.dev/docs/utilities/object/parseJsonToObject parseJsonToObject}, which ensures the root value is an object,
+ * this function returns any valid JSON structure such as arrays, strings, numbers, or objects.*
+ *
+ * This is useful when you're not sure of the root structure of the JSON, or when you expect something other than an object.
+ *
+ * @see {@link https://toolbox.nazmul-nhb.dev/docs/utilities/object/parseJsonToObject parseJsonToObject} for strict object-only parsing.
+ */
+declare const parseJSON: <T = unknown>(value: string, parsePrimitives?: boolean) => T;
+/**
+ * * Recursively parses primitive values inside objects and arrays.
+ *
+ * @typeParam T - Expected return type after parsing (default is unknown).
+ * @param input - Any input value to parse recursively.
+ * @returns Input with primitives (strings like "true", "123") converted, typed as `T`.
+ */
+declare function deepParsePrimitives<T = unknown>(input: unknown): T;
+/**
+ * * Defines a method on any prototype — including built-in prototypes — in a safe, idempotent manner.
+ * 	 - The method is non-enumerable by default and will not overwrite an existing method unless explicitly allowed.
+ *
+ * @param proto   The target prototype object (e.g., String.prototype).
+ * @param name    The method name to define on the prototype.
+ * @param impl    The function implementation for the method.
+ * @param options Optional property-descriptor settings and overwrite rules.
+ *
+ * @example
+ * // Safely augment prototype methods by extending the global interface:
+ * declare global {
+ * 	interface String {
+ * 		toBang(): string;
+ * 	}
+ * }
+ *
+ * // Define a custom method on String.prototype
+ * definePrototypeMethod(String.prototype, 'toBang', function (this: String) {
+ * 	return this.toString().concat('!');
+ * 	// or
+ * 	// return this.concat('!');
+ * });
+ *
+ * "Hi".toBang(); // "Hi!"
+ *
+ * // Attempting to redefine without overwrite option is ignored
+ * definePrototypeMethod(String.prototype, 'toBang', () => 'x'); // ignored
+ *
+ * // Overwrite intentionally using the overwrite option
+ * definePrototypeMethod(
+ *   String.prototype,
+ *   'toBang',
+ *   function (this: String) { return this.concat('!!!'); },
+ *   { overwrite: true }
+ * );
+ *
+ * "Hi".toBang(); // "Hi!!!"
+ */
+declare function definePrototypeMethod<Proto extends object, Name extends keyof Proto>(proto: Proto, name: Name, impl: (...args: unknown[]) => unknown, options?: ProtoMethodOptions): void;
+//#endregion
+//#region src/utils/xtras.d.ts
+/**
+ * @function `getCountryByPhone` Get country details by matching the country code in the given phone number.
+ * @param phone - The phone number to look up, can be a string or a number. It will be normalized by removing any non-digit character before matching against the country codes.
+ * @returns An array of country details that match the provided phone number. Each country detail includes the country name, country code, ISO short code, and ISO code. If the input is invalid (not a primitive value or an empty string), an empty array will be returned.
+ *
+ * @remarks
+ * - The function uses the {@link COUNTRIES} constant, which is an array of country details, to find matches based on the normalized phone number.
+ * - The normalization process removes any non-digit character from the input phone number to ensure consistent matching against the country codes.
+ * - The function checks if the input is neither an empty string nor a finite number before proceeding with the normalization and matching process. If the input is invalid, it returns an empty array.
+ * - If multiple countries share the same country code, all matching countries will be included in the returned array.
+ * - **`IMPORTANT:`** If a phone number does not start with a country code (plain local number), the function will return an empty array since it cannot determine the country. But if the number matches the country code of any country, it will return the corresponding country details even if the number is a local number.
+ *
+ * @example
+ * ```typescript
+ * const country = getCountryByPhone('+8801623732187');
+ * console.info(country);
+ * // Output: [
+ * //   {
+ * //     country_name: 'Bangladesh',
+ * //     country_code: '880',
+ * //     iso_code_short: 'BD',
+ * //     iso_code: 'BGD'
+ * //   }
+ * // ]
+ * ```
+ */
+declare function getCountryByPhone(phone: number | string): CountryDetails[];
+//#endregion
+export { Currency, Finder, Unit, Unit as UnitConverter, convertToRomanNumerals as arabicToRoman, convertToRomanNumerals, convertToRomanNumerals as integerToRoman, convertToRomanNumerals as numberToRoman, convertToRomanNumerals as numericToRoman, convertToRomanNumerals as toRoman, convertToRomanNumerals as toRomanNumeral, averageByField, averageByField as avgByField, banglaToDigit, getAverage as calculateAverage, getAverage, getAverage as getAverageOfNumbers, factorial as calculateFactorial, factorial, factorial as getFactorial, calculateHCF as calculateGCD, calculateHCF, calculateLCM as calculateLCD, calculateLCM, calculatePercentage, capitalizeString, getOrdinal as cardinalToOrdinal, getOrdinal as convertNumberToOrdinal, getOrdinal as convertToOrdinal, getOrdinal, getOrdinal as getOrdinalNumber, getOrdinal as numberToOrdinal, numberToWordsOrdinal as cardinalWordsToOrdinal, numberToWordsOrdinal as convertNumberToWordsOrdinal, numberToWordsOrdinal, clampNumber, cloneObject, naturalSort as compareNaturally, naturalSort as compareSorter, naturalSort, naturalSort as naturalSortForString, computeTextDiff, convertArrayToString, convertArrayToString as joinArrayElements, formatCurrency as convertNumberToCurrency, formatCurrency, numberToWords as convertNumberToWords, numberToWords, convertObjectValues, romanToInteger as convertRomanToArabic, romanToInteger as convertRomanToInteger, romanToInteger as convertRomanToNumeric, romanToInteger as romanToArabic, romanToInteger, romanToInteger as romanToNumeric, convertStringCase, convertToDecimal, convertToDecimal as convertToFixed, wordsToNumber as convertWordToNumber, wordsToNumber as convertWordsToNumber, wordsToNumber as wordToNumber, wordsToNumber, countInstanceMethods, countInstanceMethods as getInstanceMethodsCount, countObjectFields, countStaticMethods, countStaticMethods as getStaticMethodsCount, countWords, countWords as countWordsInString, countWords as wordCount, createOptionsArray, debounceAction, deepParsePrimitives, deepParsePrimitives as parsePrimitivesDeep, definePrototypeMethod, deleteFields, deleteFields as deleteObjectFields, deleteFields as omitFields, deleteFields as omitObjectFields, deleteFields as removeFields, deleteFields as removeObjectFields, digitToBangla, getDuplicates as extractDuplicates, getDuplicates as extractDuplicatesFromArray, getDuplicates, getDuplicates as getDuplicatesFromArray, extractEmails, extractObjectKeys as extractKeys, extractObjectKeys, extractObjectKeysDeep as extractKeysDeep, extractObjectKeysDeep, findMissingElements as extractMissingElements, findMissingElements, findMissingElements as getMissingElements, extractNewFields, extractNumbersFromString as extractNumbers, extractNumbersFromString, extractNumbersFromString as parseNumbersFromText, extractURLs, extractUpdatedAndNewFields, extractUpdatedFields, getFactors as factorsOf, getFactors as getDivisors, getFactors, fibonacciGenerator, fibonacciGenerator as generateFibonacci, filterArrayOfObjects, findPrimeNumbers, findPrimeNumbers as getPrimeNumbers, flattenArray, flattenObjectDotNotation, flattenObjectKeyValue, formatUnitWithPlural as formatNumberWithPluralUnit, formatUnitWithPlural, formatUnitWithPlural as formatWithPlural, generateAnagrams, generateRandomID, getCharacterDifferences, getClassDetails, getCountryByPhone, getFibonacciSeries as getFibonacci, getFibonacciSeries as getFibonacciNumbers, getFibonacciSeries, getFibonacciSeriesMemo, getFibonacciSeriesMemo as getMemoizedFibonacci, getFibonacciSeriesMemo as getMemoizedFibonacciSeries, getInstanceGetterNames, getInstanceMethodNames, getLastArrayElement, getLevenshteinDistance, getLevenshteinDistance as levenshteinDistance, getNthFibonacci, getNumbersInRange, getRandomFloat as getRandomDecimal, getRandomFloat, getRandomNumber as getRandomInt, getRandomNumber, getStaticGetterNames, getStaticMethodNames, sumNumbers as getSumOfNumbers, sumNumbers, sumNumbers as sumOfNumbers, groupAndAverageByField, groupAndAverageByField as groupAndAvgByField, groupAndSumByField, splitArrayByProperty as groupArrayByProperty, splitArrayByProperty, isDeepEqual, isInvalidOrEmptyArray, isInvalidOrEmptyArray as isValidEmptyArray, isPrime, isPrime as isPrimeNumber, maskString, mergeAndFlattenObjects, mergeObjects, moveArrayElement, normalizeNumber, normalizeString, parseJSON, parseJSON as parseJsonDeep, parseJsonToObject, parseObjectValues, parseObjectValues as parseStringifiedObjectValues, pickFields, pickFields as pickObjectFields, pickObjectFieldsByCondition as pickFieldsByCondition, pickObjectFieldsByCondition, remapFields, remapFields as remapObjectFields, removeDuplicatesFromArray as removeDuplicates, removeDuplicatesFromArray, replaceAllInString, reverseNumber, reverseString, rotateArray, roundNumber, roundNumber as roundToDecimal, roundToNearest as roundNumberToNearestInterval, roundToNearest, roundToNearest as roundToNearestInterval, sanitizeData, shuffleArray, slugifyString, sortAnArray, splitArray, stableStringify, stripJsonEdgeGarbage, sumByField, sumDigits, sumFieldDifference, sumFieldDifference as totalDeltaByField, throttleAction, trimString, truncateString };