//#region src/utilities/camelCase.d.ts
/**
 * Converts a snake_case or kebab-case string to camelCase
 *
 * @param str - The string to convert to camelCase
 * @returns The converted camelCase string
 *
 * @example
 * camelCase('user_name') // Returns: 'userName'
 * camelCase('user-name') // Returns: 'userName'
 */
declare function camelCase(str: string): string;
//#endregion
//#region src/utilities/camelCaseObject.d.ts
type JSONCandidate = any[] | object | undefined | null | string | number | boolean;
/**
 * Recursively converts all object keys to camelCase
 *
 * @param objOrArr - Object, array, or primitive value to transform
 * @returns The input with all object keys converted to camelCase
 *
 * @example
 * camelCaseObject({ user_name: 'John', user_age: 30 })
 * // Returns: { userName: 'John', userAge: 30 }
 *
 * @example
 * camelCaseObject({ user_info: { first_name: 'John' } })
 * // Returns: { userInfo: { firstName: 'John' } }
 */
declare function camelCaseObject(objOrArr: JSONCandidate): JSONCandidate;
//#endregion
//#region src/utilities/doBatch.d.ts
/**
 * Processes an array in batches and returns results from each batch
 *
 * @param list - Array to process in batches
 * @param work - Function to execute for each batch
 * @param batchCount - Number of items per batch
 * @returns Array of results from each batch execution
 *
 * @example
 * doBatch([1,2,3,4,5,6], (batch) => batch.reduce((sum, n) => sum + n, 0), 3)
 * // Processes: [1,2,3], [4,5,6] -> Returns: [6, 15]
 *
 * @example
 * doBatch(userIds, async (batch) => await fetchUsers(batch), 10)
 * // Process users in batches of 10
 */
declare function doBatch<T, R>(list: T[], work: (list: T[], batchIndex: number) => R, batchCount: number): R[];
//#endregion
//#region src/utilities/filterJsonKeys.d.ts
type Filter = ((key: string) => boolean) | string[] | string;
/**
 * Filters a JSON structure to include only objects/arrays containing specified keys
 *
 * @param x - JSON structure to filter (object, array, or primitive)
 * @param filter - Key filter - function, array of keys, or single key string
 * @returns Filtered JSON structure containing only elements with matching keys
 *
 * @example
 * filterJsonKeys({ name: 'John', age: 30, city: 'NYC' }, ['name', 'age'])
 * // Returns: { name: 'John', age: 30 }
 *
 * @example
 * filterJsonKeys([{ id: 1, name: 'John' }, { age: 30 }], 'name')
 * // Returns: [{ id: 1, name: 'John' }]
 */
declare function filterJsonKeys(x: JSONCandidate, filter: Filter): JSONCandidate;
//#endregion
//#region src/utilities/groupByArray.d.ts
/**
 * Groups array elements into subarrays based on a key
 *
 * @param collection - Array of elements to group
 * @param getKey - Function to extract key from element, or a static key
 * @returns Array of arrays, grouped by the key
 *
 * @example
 * groupByArray(users, user => user.age)
 * // Returns: [[users with age 25], [users with age 30]]
 *
 * @example
 * groupByArray([1, 2, 3, 4], n => n % 2)
 * // Returns: [[2, 4], [1, 3]]
 */
declare function groupByArray<T, K extends string | number>(collection: T[], getKey: ((element: T) => K) | K): T[][];
//#endregion
//#region src/utilities/groupByObject.d.ts
type GroupByObject<T, K extends string | number> = { [P in K]: T[] };
/**
 * Groups array elements into an object based on a key
 *
 * @param collection - Array of elements to group
 * @param getKey - Function to extract key from element, or a static key
 * @returns Object with keys mapping to arrays of grouped elements
 *
 * @example
 * groupByObject(users, user => user.age)
 * // Returns: { 25: [users with age 25], 30: [users with age 30] }
 *
 * @example
 * groupByObject(items, item => item.type)
 * // Returns: { fruit: [fruit items], vegetable: [vegetable items] }
 */
declare function groupByObject<T, K extends string | number>(collection: T[], getKey: ((element: T) => K) | K): GroupByObject<T, K>;
//#endregion
//#region src/utilities/is.d.ts
type Falsy = undefined | null | 0 | false | '';
type Func = (...args: any[]) => any;
/**
 * Comprehensive collection of type checking utilities
 *
 * @example
 * is.string('hello') // true
 * is.notEmptyString('') // false
 *
 * @example
 * is.plainObject({ a: 1 }) // true
 * is.array([1, 2, 3]) // true
 */
declare const is: {
  /** Checks whether the candidate is a non-empty string. */
  notEmptyString: (candidate: any) => candidate is string;
  /** Checks whether the candidate is an empty string. */
  emptyString: (candidate: any) => boolean;
  /** Checks whether the candidate is an empty array. */
  emptyArray: (candidate: any) => boolean;
  /** Checks whether the candidate is a non-empty array. */
  notEmptyArray: <T>(candidate: any) => candidate is Array<T>;
  /** Checks whether the candidate is a valid number. */
  number: (candidate: any) => candidate is number;
  /** Checks whether the candidate is a string. */
  string: (candidate: any) => candidate is string;
  /** Checks whether the candidate is an integer string. */
  integerString: (candidate: any) => candidate is string;
  /** Checks whether the candidate is a numeric string. */
  numberString: (candidate: any) => candidate is string;
  /** Checks whether the candidate is null. */
  null: (candidate: any) => candidate is null;
  /** Checks whether the candidate is undefined. */
  undefined: (candidate: any) => candidate is undefined;
  /** Checks whether the candidate is null or undefined. */
  nullOrUndefined: (candidate: any) => candidate is undefined | null;
  /** Checks whether the candidate is falsy. */
  falsy: <T>(candidate: T | Falsy) => candidate is Falsy;
  /** Checks whether the candidate is truthy. */
  truthy: <T>(candidate: T | Falsy) => candidate is T;
  /** Checks whether the candidate is a function. */
  function: <T extends Func, R extends unknown>(candidate: T | R) => candidate is T;
  /** Checks whether the candidate is a non-null object. */
  object: (candidate: any) => candidate is Record<string, unknown>;
  /** Checks whether the candidate is a plain object. */
  plainObject: (candidate: any) => candidate is Record<string, unknown>;
  /** Checks whether the candidate is an array. */
  array: <T>(candidate: any) => candidate is Array<T>;
  /** Checks whether the candidate is a boolean. */
  boolean: (candidate: any) => candidate is boolean;
  /** Checks whether the candidate is a promise. */
  promise: <T>(p: Promise<T> | any) => p is Promise<T>;
  /** Checks whether the candidate is a primitive value. */
  primitive: (candidate: unknown) => candidate is string | number | boolean | null | undefined;
};
//#endregion
//#region src/utilities/promise/withMinimumResolveTime.d.ts
/**
 * Ensures a Promise takes at least a minimum amount of time to resolve
 *
 * @param minimumMilli - Minimum duration in milliseconds
 * @param promise - Promise to enforce minimum resolve time on
 * @returns Promise that resolves after at least the minimum time
 *
 * @example
 * const result = await withMinimumResolveTime(1000, fetchData())
 * // Guarantees at least 1 second delay for UX (loading spinners)
 *
 * @example
 * withMinimumResolveTime(2000, quickOperation())
 * // Will wait additional time if quickOperation finishes early
 */
declare function withMinimumResolveTime<T>(minimumMilli: number, promise: Promise<T>): Promise<T>;
//#endregion
//#region src/utilities/promise/withTimeout.d.ts
/**
 * Adds a timeout to a Promise, rejecting if the timeout is exceeded
 *
 * @param milli - Timeout duration in milliseconds
 * @param promise - Promise to add timeout to
 * @returns Promise that resolves/rejects with original promise or timeout error
 * @throws Error with message 'Promise timeout in withTimeout<T>' when timeout exceeded
 *
 * @example
 * const result = await withTimeout(5000, fetchUser(userId))
 * // Throws error if fetchUser takes more than 5 seconds
 *
 * @example
 * withTimeout(100, slowPromise())
 * // Throws timeout error after 100ms
 */
declare function withTimeout<T>(milli: number, promise: Promise<T>): Promise<T>;
//#endregion
//#region src/utilities/replaceJsonKeysRecursively.d.ts
type ReplaceJsonKeyRecursivelyOption = {
  stripUndefined?: boolean;
  replacer?: Record<string, string> | ((key: string) => string | undefined);
};
/**
 * Recursively replaces all object keys in a JSON structure using a replacer function or mapping
 *
 * @param objOrArr - Object, array, or primitive value to transform keys in
 * @param options - Configuration options for key replacement
 * @param options.stripUndefined - Whether to remove undefined values from result
 * @param options.replacer - Function or object mapping for key replacement
 * @returns The input structure with all object keys replaced according to the replacer
 *
 * @example
 * replaceJsonKeysRecursively({ old_key: 'value' }, { replacer: { 'old_key': 'new_key' } })
 * // Returns: { new_key: 'value' }
 *
 * @example
 * replaceJsonKeysRecursively({ user_name: 'John' }, { replacer: (key) => key.replace('_', '') })
 * // Returns: { username: 'John' }
 */
declare function replaceJsonKeysRecursively<T extends JSONCandidate>(objOrArr: T, options: Partial<Omit<ReplaceJsonKeyRecursivelyOption, 'keyFilter'>>): T;
//#endregion
//#region src/utilities/reverseObjectKeyValues.d.ts
/**
 * Reverses the keys and values of an object
 *
 * @param obj - Object with string or number values to reverse
 * @returns New object with keys and values swapped
 * @throws Error if any value is not a string or number
 *
 * @example
 * reverseObjectKeyValues({ a: '1', b: '2' })
 * // Returns: { '1': 'a', '2': 'b' }
 *
 * @example
 * reverseObjectKeyValues({ success: 200, error: 500 })
 * // Returns: { '200': 'success', '500': 'error' }
 */
declare function reverseObjectKeyValues<T extends Record<string, string | number>>(obj: T): T | Record<string, string>;
//#endregion
//#region src/utilities/snakeCaseObject.d.ts
/**
 * Recursively converts all object keys to snake_case
 *
 * @param objOrArr - Object, array, or primitive value to transform
 * @returns The input with all object keys converted to snake_case
 *
 * @example
 * snakeCaseObject({ userName: 'John', userAge: 30 })
 * // Returns: { user_name: 'John', user_age: 30 }
 *
 * @example
 * snakeCaseObject({ userInfo: { firstName: 'John' } })
 * // Returns: { user_info: { first_name: 'John' } }
 */
declare function snakeCaseObject(objOrArr: JSONCandidate): JSONCandidate;
//#endregion
//#region src/utilities/replaceJsonValuesRecursively.d.ts
type ReplaceJsonKeysOptions = {
  stripUndefined?: boolean;
  replacer?: Record<string, Function | any>;
  postLeafTransform?: (value: any) => string;
};
/**
 * Recursively replaces values in a JSON structure based on key matching
 *
 * @param objOrArr - Object, array, or primitive value to transform values in
 * @param options - Configuration options for value replacement
 * @param options.stripUndefined - Whether to remove undefined values from result
 * @param options.replacer - Object mapping keys to replacement values or functions
 * @param options.postLeafTransform - Function to transform leaf values after replacement
 * @returns The input structure with values replaced according to the replacer
 *
 * @example
 * replaceJsonValuesRecursively({ name: 'John', age: 30 }, { replacer: { age: 25 } })
 * // Returns: { name: 'John', age: 25 }
 *
 * @example
 * replaceJsonValuesRecursively({ count: 5 }, { replacer: { count: (val) => val * 2 } })
 * // Returns: { count: 10 }
 */
declare function replaceJsonValuesRecursively<T extends JSONCandidate>(objOrArr: T, options: Partial<Omit<ReplaceJsonKeysOptions, 'keyFilter'>>): T;
//#endregion
//#region src/utilities/capitalize.d.ts
/**
 * Capitalizes the first character of a string
 *
 * @param str - The string to capitalize
 * @returns The string with its first character capitalized
 *
 * @example
 * capitalize('hello') // Returns: 'Hello'
 * capitalize('hello world') // Returns: 'Hello world'
 */
declare function capitalize(str: string): string;
//#endregion
//#region src/utilities/filterNonNullish.d.ts
/**
 * Filters out null and undefined values from an array
 *
 * @param source - Array to filter
 * @returns New array with null and undefined values removed
 *
 * @example
 * filterNonNullish([1, null, 2, undefined, 3]) // Returns: [1, 2, 3]
 *
 * @example
 * filterNonNullish(['a', null, 'b', undefined]) // Returns: ['a', 'b']
 */
declare function filterNonNullish<T>(source: T[]): Exclude<T, null | undefined>[];
//#endregion
//#region src/utilities/filterNonNullishKeys.d.ts
type Options$1 = {
  preserveNull?: boolean;
  preserveUndefined?: boolean;
  excludeEmptyString?: boolean;
};
/**
 * Filters out object keys with null, undefined, or empty string values
 *
 * @param source - Object to filter keys from
 * @param options - Configuration options for filtering behavior
 * @param options.preserveNull - Whether to keep null values (default: false)
 * @param options.preserveUndefined - Whether to keep undefined values (default: false)
 * @param options.excludeEmptyString - Whether to exclude empty string values (default: false)
 * @returns New object with specified nullish keys removed
 *
 * @example
 * filterNonNullishKeys({ a: 1, b: null, c: undefined, d: 'hello' })
 * // Returns: { a: 1, d: 'hello' }
 *
 * @example
 * filterNonNullishKeys({ a: '', b: null }, { excludeEmptyString: true })
 * // Returns: {}
 */
declare function filterNonNullishKeys<T extends object>(source: T, options?: Options$1): T;
//#endregion
//#region src/utilities/formatJson.d.ts
/**
 * Converts a value to a formatted JSON string representation
 *
 * @param a - Value to format as JSON string
 * @returns Formatted string representation of the input value
 *
 * @example
 * formatJson({ name: 'John', age: 30 }) // Returns: '{\n  "name": "John",\n  "age": 30\n}'
 *
 * @example
 * formatJson('hello') // Returns: 'hello'
 * formatJson(123) // Returns: '123'
 */
declare function formatJson(a: any): string;
//#endregion
//#region src/utilities/generateArray.d.ts
/**
 * Generates an array of consecutive numbers from 0 to size-1
 *
 * @param size - The size of the array to generate
 * @returns Array of numbers from 0 to size-1, empty array if size < 0
 *
 * @example
 * generateArray(5) // Returns: [0, 1, 2, 3, 4]
 *
 * @example
 * generateArray(0) // Returns: []
 * generateArray(-1) // Returns: []
 */
declare function generateArray(size: number): number[];
//#endregion
//#region src/utilities/lastMatchIndex.d.ts
/**
 * Finds the last occurrence index of a substring in a string
 *
 * @param str - String to search in
 * @param match - Substring to find
 * @returns Index of last occurrence, -1 if not found
 *
 * @example
 * lastMatchIndex('hello world hello', 'hello') // Returns: 12
 *
 * @example
 * lastMatchIndex('abc def ghi', 'xyz') // Returns: -1
 */
declare function lastMatchIndex(str: string, match: string): number;
//#endregion
//#region src/utilities/lastOf.d.ts
/**
 * Gets the last element of an array
 *
 * @param arr - Array to get last element from
 * @returns Last element of the array
 *
 * @example
 * lastOf([1, 2, 3, 4]) // Returns: 4
 *
 * @example
 * lastOf(['a', 'b', 'c']) // Returns: 'c'
 * lastOf([]) // Returns: undefined
 */
declare function lastOf<T>(arr: T[]): T;
//#endregion
//#region src/utilities/numberWithComma.d.ts
/**
 * Adds comma separators to a number for better readability
 *
 * @param x - Number to format with commas (optional)
 * @returns Formatted number string with comma separators, empty string if invalid
 *
 * @example
 * numberWithComma(1234567) // Returns: '1,234,567'
 *
 * @example
 * numberWithComma(1234.56) // Returns: '1,234.56'
 * numberWithComma(undefined) // Returns: ''
 */
declare function numberWithComma(x?: number): string;
//#endregion
//#region src/utilities/padZero.d.ts
/**
 * Pads a number with leading zeros to reach the specified length
 *
 * @param number - Number to pad with zeros (optional)
 * @param len - Target length for the padded string (default: 2)
 * @returns Zero-padded string, empty string if number is invalid
 *
 * @example
 * padZero(5) // Returns: '05'
 * padZero(5, 3) // Returns: '005'
 *
 * @example
 * padZero(123, 2) // Returns: '123' (no padding needed)
 * padZero(undefined) // Returns: ''
 */
declare function padZero(number: number | undefined, len?: number): string;
//#endregion
//#region src/utilities/randomItem.d.ts
/**
 * Selects a random element from an array
 *
 * @param source - Array to select random element from
 * @returns Random element from the array
 *
 * @example
 * randomItem([1, 2, 3, 4, 5]) // Returns: random number between 1-5
 *
 * @example
 * randomItem(['apple', 'banana', 'orange']) // Returns: random fruit
 */
declare function randomItem<T>(source: T[]): T;
//#endregion
//#region src/utilities/setIntervalWithTimeout.d.ts
/**
 * Handles timeout clearing and state management
 */
declare class TimeoutHandler {
  private handlerRef;
  cleared: boolean;
  /** Returns the current timeout handle. */
  get handler(): any;
  /** Stores the current timeout handle. */
  set handler(n: any);
  /**
   * Clears the current timeout and marks the handler as cleared.
   *
   * @example
   * const handler = new TimeoutHandler()
   * handler.clear()
   */
  clear(): void;
}
/**
 * Creates a repeating timeout that can be cleared from within the callback
 *
 * @param callback - Function to execute at each interval, receives clear function
 * @param intervalMs - Interval duration in milliseconds
 * @returns Function to clear the interval
 *
 * @example
 * const stop = setIntervalWithTimeout((clear) => {
 *   console.log('Running...')
 *   if (someCondition) clear()
 * }, 1000)
 *
 * @example
 * const stop = setIntervalWithTimeout(() => {
 *   console.log('Repeating task')
 * }, 2000)
 * setTimeout(stop, 10000) // Stop after 10 seconds
 */
declare function setIntervalWithTimeout(callback: (clear: () => void) => any, intervalMs: number): () => void;
//#endregion
//#region src/utilities/snakeCase.d.ts
/**
 * Converts a string to snake_case format
 *
 * @param str - The string to convert to snake_case
 * @returns The converted snake_case string
 *
 * @example
 * snakeCase('userName') // Returns: 'user_name'
 * snakeCase('getUserById') // Returns: 'get_user_by_id'
 */
declare function snakeCase(str: string): string;
//#endregion
//#region src/utilities/toFixed.d.ts
/**
 * Safely formats a number to a specified number of decimal places
 *
 * @param number - Number to format (optional)
 * @param fractionDigits - Number of decimal places
 * @param defaultString - Default string to return if number is invalid (default: '')
 * @returns Formatted number string or default string
 *
 * @example
 * toFixed(3.14159, 2) // Returns: '3.14'
 * toFixed(5, 0) // Returns: '5'
 *
 * @example
 * toFixed(undefined, 2) // Returns: ''
 * toFixed(null, 2, 'N/A') // Returns: 'N/A'
 */
declare function toFixed(number: number | undefined, fractionDigits: number, defaultString?: string): string;
//#endregion
//#region src/utilities/toFixedIfNeed.d.ts
/**
 * Formats a number to a fixed decimal places, removing trailing zeros
 *
 * @param number - Number to format (optional)
 * @param fractionDigits - Number of decimal places
 * @param defaultString - Default string to return if number is invalid (default: '')
 * @returns Formatted number string with trailing zeros removed
 *
 * @example
 * toFixedIfNeed(3.1000, 4) // Returns: '3.1'
 * toFixedIfNeed(5.0, 2) // Returns: '5'
 *
 * @example
 * toFixedIfNeed(3.14159, 2) // Returns: '3.14'
 * toFixedIfNeed(undefined, 2, 'N/A') // Returns: 'N/A'
 */
declare function toFixedIfNeed(number: number | undefined, fractionDigits: number, defaultString?: string): string;
//#endregion
//#region src/utilities/toggled.d.ts
/**
 * Toggles an element in an array - adds if not present, removes if present
 *
 * @param arr - Array to toggle element in
 * @param element - Element to toggle
 * @returns New array with element toggled
 *
 * @example
 * toggled([1, 2, 3], 4) // Returns: [1, 2, 3, 4]
 *
 * @example
 * toggled([1, 2, 3], 2) // Returns: [1, 3]
 */
declare function toggled<T>(arr: T[], element: T): T[];
//#endregion
//#region src/utilities/toSiUnitString.d.ts
/**
 * Converts a number to a readable string with SI unit suffixes (K, M)
 *
 * @param n - Number to convert to SI unit string
 * @returns String representation with SI unit suffixes, empty string if invalid
 *
 * @example
 * toSiUnitString(1500) // Returns: '1.5K'
 * toSiUnitString(2500000) // Returns: '2.5M'
 *
 * @example
 * toSiUnitString(999) // Returns: '999'
 * toSiUnitString(1000) // Returns: '1K'
 */
declare function toSiUnitString(n: number): string;
//#endregion
//#region src/utilities/unique.d.ts
/**
 * Removes duplicate values from an array
 *
 * @param arr - Array with potential duplicate values
 * @returns New array with unique values
 *
 * @example
 * unique([1, 2, 2, 3, 3, 4])
 * // Returns: [1, 2, 3, 4]
 *
 * @example
 * unique(['apple', 'banana', 'apple'])
 * // Returns: ['apple', 'banana']
 */
declare function unique<T>(arr: T[]): T[];
//#endregion
//#region src/utilities/uniqueBy.d.ts
/**
 * Removes duplicate elements from an array by a selected key.
 *
 * @param arr - Array with potential duplicate elements
 * @param getKey - Function to extract comparison key from each element
 * @returns New array with unique elements by key (keeps first occurrence)
 *
 * @example
 * uniqueBy(
 *   [
 *     { id: 1, name: 'Alice' },
 *     { id: 2, name: 'Bob' },
 *     { id: 1, name: 'Alice v2' },
 *   ],
 *   (item) => item.id,
 * )
 * // Returns: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
 */
declare function uniqueBy<T, K>(arr: T[], getKey: (value: T) => K): T[];
//#endregion
//#region src/utilities/parseSecond.d.ts
type Result = {
  totalDay: number;
  totalHour: number;
  totalMinute: number;
  onlyHour: number;
  onlyMinute: number;
  onlySecond: number;
};
/**
 * Parses total seconds into structured time components
 *
 * @param totalSecond - Total seconds to parse (optional)
 * @returns Object containing parsed time values (days, hours, minutes, seconds)
 *
 * @example
 * parseSecond(3661) // Returns: { totalDay: 0, totalHour: 1, totalMinute: 61, onlyHour: 1, onlyMinute: 1, onlySecond: 1 }
 *
 * @example
 * parseSecond(90000) // Returns: { totalDay: 1, totalHour: 25, totalMinute: 1500, onlyHour: 1, onlyMinute: 0, onlySecond: 0 }
 */
declare function parseSecond(totalSecond?: number): Result;
//#endregion
//#region src/utilities/SecFormat.d.ts
type Formatter = (totalSecond: number) => string;
type GeneralFormats = 'mm:ss' | 'm:ss' | 'hh:mm:ss' | 'h:mm:ss' | 'hh:mm:ss_on_demand';
type SecFormats = GeneralFormats;
/**
 * Time formatting utilities for converting seconds to various time string formats
 *
 * @example
 * SecFormat.format(3661, 'hh:mm:ss') // Returns: '01:01:01'
 * SecFormat.format(125, 'mm:ss') // Returns: '02:05'
 */
declare const SecFormat: {
  /**
   * Returns the formatter for the given second format.
   *
   * @example
   * const formatter = SecFormat.get('mm:ss')
   * formatter(90) // Returns: '01:30'
   */
  get: (type: SecFormats) => Formatter;
  /**
   * Formats total seconds with the given second format.
   *
   * @example
   * SecFormat.format(3661, 'hh:mm:ss') // Returns: '01:01:01'
   */
  format: (totalSeconds: number, type: SecFormats) => string;
  /**
   * Returns the cache invalidation interval for the given second format.
   *
   * @example
   * SecFormat.invalidateIntervalSec('mm:ss') // Returns: 1
   */
  invalidateIntervalSec: (type: SecFormats) => number;
};
/**
 * Alias for SecFormat.format - formats seconds into time string
 *
 * @param totalSeconds - Total seconds to format
 * @param type - Format type (e.g., 'hh:mm:ss', 'mm:ss')
 * @returns Formatted time string
 *
 * @example
 * formatSec(3661, 'hh:mm:ss') // Returns: '01:01:01'
 * formatSec(90, 'mm:ss') // Returns: '01:30'
 */
declare const formatSec: (totalSeconds: number, type: SecFormats) => string;
//#endregion
//#region src/utilities/removeValueByKeyInObject.d.ts
/**
 * Removes specified keys from an object and returns a new object
 *
 * @param v - Object to remove keys from
 * @param key - Key or array of keys to remove
 * @returns New object with specified keys removed
 *
 * @example
 * removeValueByKeyInObject({ a: 1, b: 2, c: 3 }, 'b') // Returns: { a: 1, c: 3 }
 *
 * @example
 * removeValueByKeyInObject({ a: 1, b: 2, c: 3 }, ['a', 'c']) // Returns: { b: 2 }
 */
declare function removeValueByKeyInObject<T extends Record<string | number, any>>(v: T, key: (string | number) | (string | number)[]): T;
//#endregion
//#region src/utilities/Timer.d.ts
type Options = {
  /**
   * @default false
   */
  clear?: boolean;
};
/**
 * Creates a timer utility that manages multiple timeouts with optional clearing
 *
 * @returns Timer object with timeout and clear methods
 *
 * @example
 * const timer = createTimer()
 * timer.timeout(() => console.log('Hello'), 1000)
 * timer.clear() // Clears all timeouts
 *
 * @example
 * const timer = createTimer()
 * timer.timeout(() => console.log('First'), 1000)
 * timer.timeout(() => console.log('Second'), 2000, { clear: true }) // Clears previous timeouts
 */
declare function createTimer(): {
  clear: () => void;
  /**
   * Schedules a timeout and optionally clears earlier timeouts first.
   *
   * @example
   * const timer = createTimer()
   * timer.timeout(() => console.log('Hello'), 1000)
   */
  timeout: (fn: () => void, duration: number, {
    clear: clearOtherTimers
  }?: Options) => () => void;
};
//#endregion
//#region src/utilities/clamp.d.ts
/**
 * Clamps a number between a minimum and maximum value
 *
 * @param value - The number to clamp
 * @param min - The minimum value
 * @param max - The maximum value
 * @returns The clamped value between min and max
 *
 * @example
 * clamp(5, 0, 10) // Returns: 5
 * clamp(-5, 0, 10) // Returns: 0
 * clamp(15, 0, 10) // Returns: 10
 */
declare const clamp: (value: number, min: number, max: number) => number;
//#endregion
//#region src/utilities/interpolate.d.ts
/**
 * Maps a value from one range to another range with optional extrapolation control
 *
 * @param value - The input value to interpolate
 * @param inputRange - The input range as [min, max]
 * @param outputRange - The output range as [min, max]
 * @param extrapolate - How to handle values outside input range: 'extend' (default) or 'clamp'
 * @returns The interpolated value in the output range
 *
 * @example
 * interpolate({ value: 50, inputRange: [0, 100], outputRange: [0, 1] }) // Returns: 0.5
 * interpolate({ value: 150, inputRange: [0, 100], outputRange: [0, 1], extrapolate: 'clamp' }) // Returns: 1
 * interpolate({ value: 25, inputRange: [0, 100], outputRange: [100, 0] }) // Returns: 75
 */
declare const interpolate: ({
  value,
  inputRange,
  outputRange,
  extrapolate
}: {
  value: number;
  inputRange: [number, number];
  outputRange: [number, number];
  extrapolate?: "clamp" | "extend";
}) => number;
//#endregion
//#region src/utilities/interpolateColor.d.ts
/**
 * Interpolates between two hex colors based on a value within an input range
 *
 * @param value - The input value to interpolate color for
 * @param inputRange - The input range as [min, max]
 * @param outputRange - The output color range as [startColor, endColor] in hex format
 * @returns The interpolated color as a hex string
 *
 * @example
 * interpolateColor({ value: 50, inputRange: [0, 100], outputRange: ['#ff0000', '#00ff00'] }) // Returns: '#808000'
 * interpolateColor({ value: 0, inputRange: [0, 100], outputRange: ['#000000', '#ffffff'] }) // Returns: '#000000'
 * interpolateColor({ value: 100, inputRange: [0, 100], outputRange: ['#000000', '#ffffff'] }) // Returns: '#ffffff'
 */
declare const interpolateColor: ({
  value,
  inputRange,
  outputRange
}: {
  value: number;
  inputRange: [number, number];
  outputRange: [string, string];
}) => string;
//#endregion
export { type JSONCandidate, type ReplaceJsonKeysOptions, SecFormat, type SecFormats, TimeoutHandler, camelCase, camelCaseObject, capitalize, clamp, createTimer, doBatch, filterJsonKeys, filterNonNullish, filterNonNullishKeys, formatJson, formatSec, generateArray, groupByArray, groupByObject, interpolate, interpolateColor, is, lastMatchIndex, lastOf, numberWithComma, padZero, parseSecond, randomItem, removeValueByKeyInObject, replaceJsonKeysRecursively, replaceJsonValuesRecursively, reverseObjectKeyValues, setIntervalWithTimeout, snakeCase, snakeCaseObject, toFixed, toFixedIfNeed, toSiUnitString, toggled, unique, uniqueBy, withMinimumResolveTime, withTimeout };