@lntvow/utils 4.2.13 → 4.2.15

package/dist/utils.esm-bundler.d.ts

@@ -4,8 +4,6 @@
 type Arrayable<T> = T | T[];
 /**
  * Extracts the type of an item from an array.
- * @template T The array type.
- * @returns The type of the array's items.
  */
 type ArrayItem<T> = T extends (infer U)[] ? U : never;
 /**
@@ -22,67 +20,86 @@ type AnyObject = Record<PropertyKey, any>;
 type StringNumber = string | number;
 
 /**
- * Converts a non-array value to an array. If the target is already an array, it is returned as-is.
+ * Converts a non-array value to an array or returns the array as-is.
+ *
+ * This utility function takes any value and ensures it becomes an array. If the input
+ * is already an array, it returns the original array unchanged. If the input is not
+ * an array, it wraps the value in a new array.
+ *
  * @example
+ * castArray(1)  // => [1]
+ * castArray('hello')  // => ['hello']
+ * castArray(null)  // => [null]
  *
- * castArray(1) => [1]
+ * @example
+ * castArray([1, 2, 3])  // => [1, 2, 3]
+ * castArray(['a', 'b'])  // => ['a', 'b']
  *
- * castArray([1, 2, 3]) => [1, 2, 3]
+ * @returns Returns an array containing the input value, or the original array if already an array
  */
 declare function castArray<T>(target: Arrayable<T>): T[];
 
 /**
- * Determines whether `value` is of the `Object` type in JavaScript, including objects, arrays, and functions.
- * @returns Returns `true` if `value` is an object, otherwise `false`.
- * @example
+ * Checks if a value is of the Object type in JavaScript.
  *
- * isObject({}) => true
+ * This utility determines whether a value is an object type, which includes
+ * objects, arrays, and functions. It excludes null (which technically has
+ * typeof 'object' in JavaScript) and primitive values.
  *
- * isObject([1, 2, 3]) => true
+ * @example
+ * isObject({})           // => true
+ * isObject([1, 2, 3])    // => true
+ * isObject(function() {}) // => true
  *
- * isObject(function() {}) => true
+ * @example
+ * isObject(null)         // => false
+ * isObject(undefined)    // => false
+ * isObject('string')     // => false
  *
- * isObject(null) => false
+ * @returns Returns `true` if the value is an object, otherwise `false`
  */
 declare function isObject(value: unknown): value is AnyObject;
 
 /**
- * Determines whether `value` is a general object. A value is considered a general object if it is not `null`
- * and the result of `typeof` is "object".
+ * Checks if a value is object-like (non-null object type).
  *
- * The difference between `isObject` and `isObjectLike` is that `isObjectLike` does not treat functions as objects.
+ * This utility determines whether a value is object-like, meaning it's not null
+ * and has a typeof result of "object". Unlike `isObject`, this function excludes
+ * functions, treating only pure objects and arrays as object-like.
  *
- * @returns Returns `true` if `value` is a general object, otherwise `false`.
  * @example
+ * isObjectLike({})        // => true
+ * isObjectLike([1, 2, 3]) // => true
+ * isObjectLike(new Date()) // => true
  *
- * isObjectLike({}) => true
- *
- * isObjectLike([1, 2, 3]) => true
- *
- * isObjectLike(function() {}) => false
+ * @example
+ * isObjectLike(function() {}) // => false
+ * isObjectLike(null)          // => false
+ * isObjectLike('string')      // => false
  *
- * isObjectLike(null) => false
+ * @returns Returns `true` if the value is object-like, otherwise `false`
  */
 declare function isObjectLike(value: unknown): value is AnyObject;
 
 /**
- * Checks if a value is a plain object. A plain object is defined as an object created by the `{}` syntax
- * or constructed using `Object.create(null)`. It includes objects created by `class` or constructors,
- * as long as their internal type is `[object Object]`. It excludes arrays, functions, and other built-in objects.
+ * Checks if a value is a plain object.
  *
- * @returns Returns `true` if `value` is a plain object, otherwise `false`.
- * @example
- *
- * isPlainObject({ x: 0, y: 0 }) => true
+ * This utility determines whether a value is a plain object, defined as an object
+ * created by the `{}` syntax, `Object.create(null)`, or class constructors that
+ * maintain the `[object Object]` internal type. It excludes arrays, functions,
+ * and other built-in objects like Date, RegExp, etc.
  *
- * isPlainObject([1, 2, 3]) => false
- *
- * isPlainObject(Object.create(null)) => true
+ * @example
+ * isPlainObject({ x: 0, y: 0 })        // => true
+ * isPlainObject(Object.create(null))   // => true
+ * isPlainObject(new class Foo {}())    // => true
  *
- * isPlainObject(null) => false
+ * @example
+ * isPlainObject([1, 2, 3])             // => false
+ * isPlainObject(null)                  // => false
+ * isPlainObject(new Date())            // => false
  *
- * class Foo {}
- * isPlainObject(new Foo()) => true
+ * @returns Returns `true` if the value is a plain object, otherwise `false`
  */
 declare function isPlainObject(value: unknown): value is AnyObject;
 
@@ -92,110 +109,109 @@ declare function isPlainObject(value: unknown): value is AnyObject;
 declare const objectToString: () => string;
 /**
  * Converts a value to its type string representation
- * @param value The value to convert
+ *
  * @returns The type string of the value (e.g., "[object Object]")
  */
 declare const toTypeString: (value: unknown) => string;
 /**
  * Extracts the type name from the type string
- * @param value The value to extract the type from
+ *
  * @returns The type name (e.g., "Object", "Array")
  */
 declare const toTypeValue: (value: unknown) => string;
 /**
  * Checks if a value is a string
- * @param val The value to check
+ *
  * @returns `true` if the value is a string, otherwise `false`
  */
 declare const isString: (val: unknown) => val is string;
 /**
  * Checks if a value is a valid number (excluding NaN and Infinity).
- * @param val The value to check
+ *
  * @returns `true` if the value is a finite number, otherwise `false`
  */
 declare const isNumber: (val: unknown) => val is number;
 /**
  * Checks if a value is a boolean
- * @param val The value to check
+ *
  * @returns `true` if the value is a boolean, otherwise `false`
  */
 declare const isBoolean: (val: unknown) => val is boolean;
 /**
  * Checks if a value is null
- * @param val The value to check
+ *
  * @returns `true` if the value is null, otherwise `false`
  */
 declare const isNull: (val: unknown) => val is null;
 /**
  * Checks if a value is undefined
- * @param val The value to check
+ *
  * @returns `true` if the value is undefined, otherwise `false`
  */
 declare const isUndef: (val: unknown) => val is undefined;
 /**
  * Checks if a value is a symbol
- * @param val The value to check
+ *
  * @returns `true` if the value is a symbol, otherwise `false`
  */
 declare const isSymbol: (val: unknown) => val is symbol;
 /**
  * Checks if a value is an array
- * @param val The value to check
+ *
  * @returns `true` if the value is an array, otherwise `false`
  */
 declare const isArray: (arg: any) => arg is any[];
 /**
  * Checks if a value is a function
- * @param val The value to check
+ *
  * @returns `true` if the value is a function, otherwise `false`
  */
 declare const isFunction: (val: unknown) => val is Function;
 /**
  * Checks if a value is a Map
- * @param val The value to check
+ *
  * @returns `true` if the value is a Map, otherwise `false`
  */
 declare const isMap: (val: unknown) => val is Map<any, any>;
 /**
  * Checks if a value is a Set
- * @param val The value to check
+ *
  * @returns `true` if the value is a Set, otherwise `false`
  */
 declare const isSet: (val: unknown) => val is Set<any>;
 /**
  * Checks if a value is a Date
- * @param val The value to check
+ *
  * @returns `true` if the value is a Date, otherwise `false`
  */
 declare const isDate: (val: unknown) => val is Date;
 /**
  * Checks if a value is a RegExp
- * @param val The value to check
+ *
  * @returns `true` if the value is a RegExp, otherwise `false`
  */
 declare const isRegExp: (val: unknown) => val is RegExp;
 /**
  * Checks if a value is a Promise
- * @param val The value to check
+ *
  * @returns `true` if the value is a Promise, otherwise `false`
  */
 declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
 /**
  * Checks if a value is undefined or null
- * @param val The value to check
+ *
  * @returns `true` if the value is undefined or null, otherwise `false`
  */
 declare const isNil: (val: unknown) => val is undefined | null;
 /**
  * Checks if a value is defined (not undefined or null)
- * @param val The value to check
+ *
  * @returns `true` if the value is defined, otherwise `false`
  */
 declare const isDef: <T>(val: T) => val is NonNullable<T>;
 /**
  * Checks if two values are different
- * @param oldValue The old value
- * @param newValue The new value
+ *
  * @returns `true` if the values are different, otherwise `false`
  */
 declare const hasChanged: (oldValue: unknown, newValue: unknown) => boolean;
@@ -221,35 +237,36 @@ declare const hasChanged: (oldValue: unknown, newValue: unknown) => boolean;
  * @returns True if the object contains circular references, false otherwise
  *
  * @throws {Error} When `obj` is not an object
- *
- * @remarks
- * - Supports both plain objects, function objects, and arrays
- * - Handles nested objects and mixed object/array structures
  */
 declare function hasCircularReference(obj: AnyObject): boolean;
 
 /**
- * Exclude certain properties from an object
- * @param target The target object
- * @param properties The properties to exclude
- * @module
- * @example
+ * Creates a new object with specified properties excluded from the original object.
+ *
+ * This utility removes specific properties from an object and returns a new object
+ * containing all other properties. It supports both single property names and arrays
+ * of property names, creating a deep clone to prevent reference sharing.
  *
- * omit({ a: 1, b: 2, c: 3 }, 'a') => { b: 2, c: 3 }
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, 'a')  // => { b: 2, c: 3 }
+ * omit({ a: 1, b: 2, c: 3 }, ['a', 'b'])  // => { c: 3 }
  *
- * omit({ a: 1, b: 2, c: 3 }, ['a', 'b']) => { c: 3 }
+ * @returns Returns a new object without the specified properties
  */
 declare function omit<T extends object, K extends keyof T>(target: T, properties: Arrayable<K>): Omit<T, K>;
 
 /**
- * Extract specific properties from an object
- * @param target The target object
- * @param properties The properties to extract
- * @example
+ * Creates a new object with only the specified properties from the original object.
  *
- * pick({ a: 1, b: 2, c: 3 }, 'a') => { a: 1 }
+ * This utility extracts specific properties from an object and returns a new object
+ * containing only those properties. It supports both single property names and arrays
+ * of property names, with optional deep cloning to prevent reference sharing.
  *
- * pick({ a: 1, b: 2, c: 3 }, ['a', 'b']) => { a: 1, b: 2 }
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, 'a')  // => { a: 1 }
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'b'])  // => { a: 1, b: 2 }
+ *
+ * @returns Returns a new object with only the specified properties
  */
 declare function pick<T extends object, K extends keyof T>(target: T, properties: Arrayable<K>, options?: PickOptions): Pick<T, K>;
 interface PickOptions {
@@ -271,21 +288,53 @@ interface PickOptions {
 }
 
 /**
- * Generate random array
- * @example generateRandomArray(4, () => 1) => [1, 1, 1, 1]
- * */
-declare function generateRandomArray<T>(num: number, cb: (item?: unknown, index?: number) => T): T[];
+ * Generates an array of specified length with elements created by a callback function.
+ *
+ * This utility creates an array by calling the provided callback function the specified number of times.
+ * Each element in the array is the result of invoking the callback function. The callback is called
+ * independently for each element, allowing for dynamic generation of array contents.
+ *
+ * @example
+ * generateRandomArray(4, () => 1)  // => [1, 1, 1, 1]
+ * generateRandomArray(3, () => Math.random())  // => [0.123, 0.456, 0.789]
+ * generateRandomArray(2, () => new Date())  // => [Date, Date]
+ *
+ * @returns Returns an array of length `num` with elements created by calling `cb`
+ *
+ * @throws {Error} When `num` is not a non-negative integer
+ * @throws {Error} When `cb` is not a function
+ */
+declare function generateRandomArray<T>(num: number, cb: () => T): T[];
 
 /**
- * Generate random color
- * @example generateRandomColor() => '#f36a38'
- * */
+ * Generates a random hex color string in the format '#RRGGBB'.
+ *
+ * This utility creates a random color by generating a random integer between 0 and 0xFFFFFF,
+ * then converting it to a 6-digit hexadecimal string. The result is always a valid CSS color value.
+ *
+ * @example
+ * generateRandomColor()  // => '#f36a38'
+ * generateRandomColor()  // => '#00ffcc'
+ * generateRandomColor()  // => '#123456'
+ *
+ * @returns Returns a string representing a random color in hex format, always starting with '#'.
+ */
 declare function generateRandomColor(): string;
 
 /**
- * Generate random date
- * @example generateRandomDate() => '2021-07-01 08:51:34'
- * */
+ * Generates a random date within a specified time range.
+ *
+ * This utility creates random dates between start and end boundaries with customizable
+ * date formatting. It intelligently handles date validation and ensures the generated
+ * date falls within the specified range while respecting calendar constraints.
+ *
+ * @example
+ * generateRandomDate()                              // => '2021-07-01 08:51:34'
+ * generateRandomDate({ start: '2020-01-01' })       // => '2022-03-15 14:23:45'
+ * generateRandomDate({ format: 'YYYY-MM-DD' })      // => '2021-11-28'
+ *
+ * @returns Returns a randomly generated date string in the specified format
+ */
 declare function generateRandomDate(options?: GenerateRandomDate): string;
 interface GenerateRandomDate {
     /**
@@ -306,15 +355,35 @@ interface GenerateRandomDate {
 }
 
 /**
- * Generate random email
- * @example generateRandomEmail() => lZtJqMl0dyTO3WDGzFDO@gmail.com
+ * Generates a random email address with realistic formatting.
+ *
+ * This utility creates random email addresses using common email providers
+ * and ensures proper email format validation. The generated emails have
+ * random usernames and are selected from a pool of realistic domains.
+ *
+ * @example
+ * generateRandomEmail() // => 'lZtJqMl0dyTO3WDGzFDO@gmail.com'
+ * generateRandomEmail() // => 'Kj9mP2xQ@outlook.com.cn'
+ * generateRandomEmail() // => 'abc123@qq.com'
+ *
+ * @returns Returns a randomly generated email address string
  */
 declare function generateRandomEmail(): string;
 
 /**
- * Generate random float number within range
- * @example generateRandomFloat() => 0.35
- * */
+ * Generates a random floating-point number within a specified range.
+ *
+ * This utility creates random float values between minimum and maximum boundaries
+ * with support for precision control. It accepts either a simple maximum value
+ * or a configuration object with detailed range and precision settings.
+ *
+ * @example
+ * generateRandomFloat()                      // => 0.35
+ * generateRandomFloat(10)                    // => 7.23 (between 0 and 10)
+ * generateRandomFloat({ min: 1, max: 5 })    // => 3.47 (between 1 and 5)
+ *
+ * @returns Returns a random floating-point number within the specified range
+ */
 declare function generateRandomFloat(options?: GenerateRandomFloat): number;
 type GenerateRandomFloat = number | {
     /**
@@ -335,34 +404,68 @@ type GenerateRandomFloat = number | {
 };
 
 /**
- * Generate random Chinese ID card number
- * @example generateRandomIdCard() => '410304200210165258'
+ * Generates a random Chinese ID card number with valid format.
+ *
+ * This utility creates random Chinese identity card numbers following the
+ * standard 18-digit format. The generated numbers include area codes, birth dates,
+ * sequence numbers, and check digits, maintaining the structural validity of real ID numbers.
+ *
+ * @example
+ * generateRandomIdCard() // => '410304200210165258'
+ * generateRandomIdCard() // => '11010519901215002X'
+ * generateRandomIdCard() // => '330106198512234567'
+ *
+ * @returns Returns a randomly generated Chinese ID card number string
  */
 declare function generateRandomIdCard(): string;
 
 /**
- * Generate random mobile phone number
- * @example generateRandomMobilePhone() => 13012345678
+ * Generates a random Chinese mobile phone number with valid prefix.
+ *
+ * This utility creates random Chinese mobile phone numbers using authentic
+ * carrier prefixes (13x, 14x, 15x, 16x, 17x, 18x, 19x) followed by random
+ * digits to form complete 11-digit phone numbers.
+ *
+ * @example
+ * generateRandomMobilePhone() // => '13012345678'
+ * generateRandomMobilePhone() // => '18598765432'
+ * generateRandomMobilePhone() // => '15611223344'
+ *
+ * @returns Returns a randomly generated Chinese mobile phone number string
  */
 declare function generateRandomMobilePhone(): string;
 
 /**
- * Generate random string from source
- * @param num Number of times to randomly get items from source
- * @example generateRandomStringFromSource(4, ['1', 'b', 'c', 'd', 'e']) => 'dea1'
- * */
+ * Generates a random string by selecting characters from a provided source array.
+ *
+ * This utility creates a string of specified length by randomly selecting items from
+ * the source array. Each character in the result is independently chosen, allowing
+ * for repetition of characters from the source.
+ *
+ * @example
+ * generateRandomStringFromSource(4, ['1', 'b', 'c', 'd', 'e'])  // => 'dea1'
+ * generateRandomStringFromSource(6, ['a', 'b', 'c'])  // => 'abcabc'
+ *
+ * @returns Returns a string composed of randomly selected characters from the source
+ *
+ * @throws {Error} When `num` is not greater than 0
+ * @throws {Error} When `source` is not a non-empty array
+ */
 declare function generateRandomStringFromSource(num: number, source: (number | string)[]): string;
 
 /**
- * Returns a random integer within a specified range.
- *
- * @example
+ * Generates a random integer within a specified range.
  *
- * getRandomInt() => 217342
+ * This utility generates random integers with flexible range specification. It accepts
+ * either a simple maximum value or an options object with min/max boundaries.
+ * The function ensures the generated number is inclusive of both boundaries.
  *
- * getRandomInt(100) => 35
+ * @example
+ * getRandomInt()                    // => 217342 (random large integer)
+ * getRandomInt(100)                 // => 35 (between 1 and 100)
+ * getRandomInt({ min: 1, max: 100 }) // => 42 (between 1 and 100)
  *
- * getRandomInt({ min: 1, max: 100 }) => 42
+ * @returns Returns a random integer within the specified range (inclusive)
  */
 declare function getRandomInt(options?: Options$1): number;
 type Options$1 = {
@@ -384,15 +487,33 @@ type Options$1 = {
  | number;
 
 /**
- * Get random item from array
- * @example  getRandomItem([0, 1, 2, 3, 4]) => 2
+ * Selects a random item from an array.
+ *
+ * This utility randomly picks one element from the provided array using
+ * a uniform distribution. Each element has an equal probability of being selected.
+ *
+ * @example
+ * getRandomItem([0, 1, 2, 3, 4])     // => 2
+ * getRandomItem(['a', 'b', 'c'])     // => 'b'
+ * getRandomItem([{ id: 1 }, { id: 2 }]) // => { id: 1 }
+ *
+ * @returns Returns a randomly selected item from the array
  */
 declare function getRandomItem<T>(list: T[]): T;
 
 /**
- * Returns a random string containing uppercase letters, lowercase letters, numbers, and optionally extra characters.
+ * Generates a random string with customizable character sets and length.
+ *
+ * This utility creates random strings using a combination of uppercase letters,
+ * lowercase letters, numbers, and optional extra characters. It supports flexible
+ * configuration including length ranges, prefixes, suffixes, and character set customization.
+ *
+ * @example
+ * getRandomString()                           // => 'lZtJqMl0dyTO3WDG'
+ * getRandomString({ length: 8 })              // => 'Kj9mP2xQ'
+ * getRandomString({ prefix: 'user_', length: 6 }) // => 'user_Abc123'
  *
- * @example getRandomString() => 'lZtJqMl0dyTO3WDG'
+ * @returns Returns a randomly generated string based on the specified options
  */
 declare function getRandomString(options?: Options): string;
 type Options = {
@@ -447,44 +568,109 @@ type Options = {
  | number;
 
 /**
- * Returns a random URL string.
+ * Generates a random URL string with realistic structure.
+ *
+ * This utility creates random URLs with authentic components including protocols,
+ * domain names, top-level domains, and query parameters. The generated URLs
+ * follow standard web address conventions with various parameter combinations.
+ *
+ * @example
+ * getRandomUrl() // => 'https://06hcfsdjubH.cn?name=aB3x'
+ * getRandomUrl() // => 'http://mywebsite.com?id=12345'
+ * getRandomUrl() // => 'https://example.org?token=a1b2c3d4e5f6g7h8'
  *
- * @example  getRandomUrl() => 'https://06hcfsdjubH.cn'
+ * @returns Returns a randomly generated URL string
  */
 declare function getRandomUrl(): string;
 
 /**
- * Convert decimal to binary
- * @example decimalToBinary(233) => '11101001'
+ * Converts a decimal number to its binary representation.
+ *
+ * This utility transforms a decimal number into a binary string using the standard
+ * division-by-2 algorithm. The function uses a stack-based approach to ensure
+ * the correct order of binary digits in the result.
+ *
+ * @example
+ * decimalToBinary(233) // => '11101001'
+ * decimalToBinary(10)  // => '1010'
+ * decimalToBinary(0)   // => ''
+ *
+ * @returns Returns the binary representation as a string
  */
 declare function decimalToBinary(decNumber: number): string;
 /**
- * Base64 encode
- * @example base64Encode('hello') => 'aGVsbG8='
+ * Encodes a string to Base64 format.
+ *
+ * This utility converts a string into its Base64 encoded representation using
+ * the standard Base64 character set. The function handles UTF-8 characters
+ * and applies proper padding as required by the Base64 specification.
+ *
+ * @example
+ * base64Encode('hello')     // => 'aGVsbG8='
+ * base64Encode('Hi there!') // => 'SGkgdGhlcmUh'
+ * base64Encode('')          // => ''
+ *
+ * @returns Returns the Base64 encoded string
  */
 declare function base64Encode(str: string): string;
 /**
- * Base64 decode
- * @example base64Decode('aGVsbG8=') => 'hello'
+ * Decodes a Base64 encoded string back to its original format.
+ *
+ * This utility converts a Base64 encoded string back to its original text representation.
+ * The function handles standard Base64 padding and properly reconstructs the original
+ * characters from the encoded binary data.
+ *
+ * @example
+ * base64Decode('aGVsbG8=')     // => 'hello'
+ * base64Decode('SGkgdGhlcmUh') // => 'Hi there!'
+ * base64Decode('')             // => ''
+ *
+ * @returns Returns the decoded original string
  */
 declare function base64Decode(str: string): string;
 
 /**
- * compose
- * @param fns Any functions
+ * Composes multiple functions into a single function, executing them from left to right.
+ *
+ * This utility creates a new function that represents the composition of the provided functions.
+ * The output of each function is passed as input to the next function in the sequence.
+ *
+ * @example
+ * const add = (x: number) => x + 1
+ * const multiply = (x: number) => x * 2
+ * const composed = compose(add, multiply)
+ * composed(5) // => 12 (5 + 1 = 6, then 6 * 2 = 12)
+ *
+ * @returns Returns the composed function
  */
 declare function compose(...fns: ((...args: any[]) => any)[]): (...args: any[]) => any;
 /**
- * Compose from right to left
- * @param fns Any functions
+ * Composes multiple functions into a single function, executing them from right to left.
+ *
+ * This utility creates a new function that represents the composition of the provided functions
+ * in reverse order. The output of each function is passed as input to the previous function.
+ *
+ * @example
+ * const add = (x: number) => x + 1
+ * const multiply = (x: number) => x * 2
+ * const composed = composeRight(add, multiply)
+ * composed(5) // => 11 (5 * 2 = 10, then 10 + 1 = 11)
+ *
+ * @returns Returns the composed function
  */
 declare function composeRight(...fns: ((...args: any[]) => any)[]): (...args: any[]) => any;
 
 /**
- * Debounce function
- * @param target Target function
- * @param wait Wait time, default 500ms
- * @example debounce(() => console.log('debounce'), 500)
+ * Creates a debounced function that delays invoking the provided function until after the specified time period has elapsed since the last time it was called.
+ *
+ * This utility prevents a function from being called too frequently by delaying its execution.
+ * Each new call resets the delay timer, ensuring the function only executes after the specified
+ * wait period of inactivity.
+ *
+ * @example
+ * debounce(() => console.log('debounce'), 500)
+ *
+ * @returns Returns the debounced function
  */
 declare function debounce(target: Function, wait?: number): (...args: any[]) => void;
 
@@ -493,7 +679,7 @@ declare function debounce(target: Function, wait?: number): (...args: any[]) =>
  *
  * This utility performs a complete deep copy of the input value, handling complex nested structures,
  * circular references, and various JavaScript types. It preserves prototype chains, property descriptors,
- * and handles special objects like Date, RegExp, Map, Set, and more.
+ * Symbol properties, and handles special objects like Date, RegExp, Map, Set, and more.
  *
  * @example
  * deepClone({ name: 'test' }) => { name: 'test' }
@@ -502,19 +688,6 @@ declare function debounce(target: Function, wait?: number): (...args: any[]) =>
  * deepClone({ user: { name: 'John', data: [1, 2] } }) => { user: { name: 'John', data: [1, 2] } }
  *
  * @returns A deep clone of the input value with all nested references copied
- *
- * @remarks
- * - Handles circular references to prevent infinite loops
- * - Preserves prototype chains for objects and arrays
- * - Maintains property descriptors including getters and setters
- * - Supports Symbol properties and Symbol keys
- * - Clones Date objects to new Date instances with same time
- * - Clones RegExp objects maintaining their behavior
- * - Returns Promise objects as-is (promises are not cloned)
- * - Recursively clones Map and Set collections including their keys/values
- * - Handles non-object-like values (primitives) by returning them directly
- * - Preserves array subclass prototypes and custom array-like objects
- * - Maintains all property metadata and descriptors
  */
 declare function deepClone<T>(target: T): T;
 
@@ -533,16 +706,6 @@ declare function deepClone<T>(target: T): T;
  * deepMerge({ data: { x: 1 } }, { data: { y: 2 } }) => { data: { x: 1, y: 2 } }
  *
  * @returns A new merged object combining properties from both template and source
- *
- * @remarks
- * - Template object provides default values and structure
- * - Source object values override template values for matching keys
- * - Nested objects are recursively merged rather than replaced
- * - Arrays can be merged or replaced based on mergeStrategy option
- * - Property descriptors (getters, setters, etc.) are preserved
- * - Deep cloning is enabled by default to prevent original object mutation
- * - Non-plain objects in source will replace corresponding template values
- * - Supports Symbol properties and maintains prototype relationships
  */
 declare function deepMerge(template: AnyObject, source: AnyObject, options?: DeepMergeOptions): any;
 interface DeepMergeOptions {
@@ -570,21 +733,57 @@ interface DeepMergeOptions {
     mergeStrategy?: 'merge' | 'replace';
 }
 
+/**
+ * Custom error class for utility functions.
+ *
+ * This error class extends the native Error class and provides a consistent
+ * way to throw errors with a specific scope or context name.
+ */
 declare class UtilsError extends Error {
     constructor(m: string, name?: string);
 }
+/**
+ * Throws a formatted error with scope information.
+ *
+ * This utility creates and throws a UtilsError with a formatted message
+ * that includes the scope context for better debugging and error tracking.
+ *
+ * @example
+ * throwError('validation', 'Invalid input')  // throws Error: [validation] Invalid input
+ *
+ * @throws {UtilsError} Always throws an error with the formatted message
+ */
 declare function throwError(scope: string, message: string): void;
+/**
+ * Logs a warning message to the console.
+ *
+ * This utility function provides a flexible way to log warnings, accepting either
+ * an Error object directly or scope and message parameters to create a warning.
+ * It outputs the warning to the console for debugging purposes.
+ *
+ * @example
+ * debugWarn('validation', 'Deprecated API usage')
+ * debugWarn(new Error('Something went wrong'))
+ *
+ * @returns No return value - outputs warning to console
+ */
 declare function debugWarn(err: Error): void;
 declare function debugWarn(scope: string, message: string): void;
-declare const deprecated: ({ from, replacement, version, type, }: {
-    from: string;
-    replacement: string;
-    version: string;
-    type?: "API";
-}) => void;
-declare function throwErrorInvalidTypeMessage(scope: string, key: string, type: string, value: unknown): void;
-declare function debugWarnInvalidTypeMessage(scope: string, key: string, type: string, value: unknown): void;
 
+/**
+ * Logs informational messages with consistent formatting.
+ *
+ * This utility provides a standardized logging interface that formats messages
+ * with a '[Log]' prefix and the provided name. Supports multiple arguments
+ * that will be displayed as context information.
+ *
+ * @example
+ * log('API', 'Request completed')
+ * log('User', { id: 1, name: 'John' })
+ * log('Debug', 'value1', 'value2', { extra: 'data' })
+ *
+ * @returns No return value - outputs directly to console
+ */
 declare const log: {
     (name: unknown, ...arg: unknown[]): void;
     info(name: unknown, ...arg: unknown[]): void;
@@ -643,16 +842,6 @@ declare global {
  * @throws {Error} When `encodeDotInKeys` is not a boolean
  * @throws {Error} When `commaRoundTrip` is not a boolean
  * @throws {Error} When `allowEmptyArrays` is not a boolean
- *
- * @remarks
- * - Supports nested objects and arrays with configurable formatting
- * - Handles null, undefined, and empty values according to specified options
- * - Provides multiple array serialization formats (indices, brackets, comma)
- * - Supports both bracket notation and dot notation for nested objects
- * - Uses standard URL encoding with configurable key/value encoding options
- * - Returns empty string for non-object inputs
- * - Preserves key order from the original object
- * - Supports custom delimiters and query prefixes
  */
 declare function qsStringify(obj: AnyObject, options?: StringifyOptions): string;
 interface StringifyOptions {
@@ -784,10 +973,6 @@ declare const qs: {
      * @returns A URL-encoded query string
      *
      * @throws {Error} When `obj` is not an object
-     *
-     * @remarks
-     * - Uses native URLSearchParams for encoding
-     * - Only supports flat objects (no nested structures)
      */
     stringify: (obj: AnyObject) => string;
     /**
@@ -811,12 +996,6 @@ declare const qs: {
      * @returns A plain object containing the parsed key-value pairs as strings
      *
      * @throws {Error} When `str` is not a string
-     *
-     * @remarks
-     * - Uses native URLSearchParams for parsing and decoding
-     * - All values are returned as strings (no automatic type conversion)
-     * - Handles standard URL encoding/decoding automatically
-     * - Does not support nested objects or arrays
      */
     parse: (str: string) => {
         [k: string]: string;
@@ -845,41 +1024,24 @@ declare const qs: {
      *
      * @throws {Error} When `url` is not a string
      * @throws {Error} When `obj` is not an object
-     *
-     * @remarks
-     * - Automatically detects existing query strings and uses appropriate separators
-     * - Handles edge cases like trailing '?' or '&' characters
-     * - Preserves existing query parameters in the URL
-     * - Uses the same encoding rules as the stringify method
      */
     appendQueryString: (url: string, obj: AnyObject) => string;
 };
 
 /**
- * Throttle function
- * @param target Target function
- * @param wait Wait time, default 500ms
- * @example throttle(() => console.log('hello world'), 500)
+ * Creates a throttled function that only invokes the provided function at most once per specified time period.
+ *
+ * This utility limits the rate at which a function can fire. When the throttled function is called,
+ * it will invoke the original function immediately if it hasn't been called within the wait period.
+ * Subsequent calls within the wait period are ignored until the period expires.
+ *
+ * @example
+ * throttle(() => console.log('hello world'), 500)
+ *
+ * @returns Returns the throttled function
  */
 declare function throttle(target: Function, wait?: number): (...args: any[]) => any;
 
-/**
- * Validates Chinese characters, letters, and digits
- */
-declare function validatorChineseOrEnglishOrNumber(value: string): boolean;
-/**
- * Validates Chinese characters and English letters
- */
-declare function validatorChineseOrEnglish(value: string): boolean;
-/**
- * Validates uppercase letters, digits, and special characters including !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
- */
-declare function validatorUppercaseOrNumbersOrSpecial(value: string): boolean;
-/**
- * Validates uppercase letters, digits, and underscore
- */
-declare function validatorUppercaseOrNumbersOrUnderline(value: string): boolean;
-
 /**
  * Executes an asynchronous function with retry logic.
  *
@@ -921,15 +1083,6 @@ declare function validatorUppercaseOrNumbersOrUnderline(value: string): boolean;
  * @throws {Error} When `signal` is not an AbortSignal object
  * @throws {Promise rejection Error} "Operation Cancelled" when the operation is aborted via AbortSignal
  * @throws {Promise rejection any} The original error from `fn` when all retry attempts are exhausted
- *
- * @remarks
- * - Uses exponential backoff when enabled: delay × 2^(attempt-1)
- * - Supports cancellation via AbortSignal at any point during execution
- * - Logs retry attempts for debugging purposes
- * - Validates all input parameters and throws descriptive errors
- * - Cleans up event listeners to prevent memory leaks
- * - Returns immediately on first successful execution
- * - Preserves the original error when all retries fail
  */
 declare function withRetry<T>(options: WithRetryOptions<T>): Promise<T>;
 interface WithRetryOptions<T> {
@@ -977,49 +1130,6 @@ interface WithRetryOptions<T> {
     signal?: AbortSignal;
 }
 
-/**
- * Validates if the value contains only digits
- */
-declare function isNumberOrNumberString(val: string): boolean;
-/**
- * Validates if the value contains only English letters
- */
-declare function isEnglishAphabet(val: string): boolean;
-/**
- * Validates if the value contains only uppercase letters
- */
-declare function isUpperCase(val: string): boolean;
-/**
- * Validates if the value contains only uppercase letters and digits
- */
-declare function isUpperCaseAndNumber(val: string): boolean;
-/**
- * Validates if the value contains only uppercase letters, digits and Chinese characters
- */
-declare function isUpperCaseAndNumberAndChinese(val: string): boolean;
-/**
- * Validates if the value contains only lowercase letters
- */
-declare function isLowerCase(val: string): boolean;
-/**
- * Validates if the value contains only lowercase letters and digits
- */
-declare function isLowerCaseAndNumber(val: string): boolean;
-/**
- * Validates if the value contains only lowercase letters, digits and Chinese characters
- */
-declare function isLowerCaseAndNumberAndChinese(val: string): boolean;
-/**
- * Validates whether the value is a Chinese string.
- *
- * @example
- *
- * isChineseString('你好') => true
- *
- * isChineseString('hello') => false
- */
-declare function isChineseString(val: string): boolean;
-
 /**
  * Validates whether a string represents a valid float number.
  *
@@ -1038,14 +1148,6 @@ declare function isChineseString(val: string): boolean;
  * isFloat('abc') => false (non-numeric)
  *
  * @returns Returns `true` if the string is a valid float, `false` otherwise
- *
- * @remarks
- * - Accepts positive floats (e.g., "1.23", "999.5")
- * - Accepts negative floats (e.g., "-1.23", "-999.5")
- * - Accepts zero with decimal point (e.g., "0.0", "-0.0")
- * - Rejects integers without decimal point (e.g., "7", "-7")
- * - Rejects numbers with no digits after decimal (e.g., "1.", "-2.")
- * - Rejects non-numeric strings (e.g., "abc", "1.2a")
  */
 declare function isFloat(val: string): boolean;
 /**
@@ -1065,13 +1167,6 @@ declare function isFloat(val: string): boolean;
  * isPositiveFloat('7') => false (integer)
  *
  * @returns Returns `true` if the string is a positive float, `false` otherwise
- *
- * @remarks
- * - Accepts only positive floats greater than zero (e.g., "1.23", "0.5")
- * - Rejects zero with decimal point (e.g., "0.0", "0.00")
- * - Rejects negative floats (e.g., "-1.23", "-0.5")
- * - Rejects integers (e.g., "7", "-7")
- * - Rejects non-numeric strings (e.g., "abc", "1.2a")
  */
 declare function isPositiveFloat(val: string): boolean;
 /**
@@ -1091,13 +1186,6 @@ declare function isPositiveFloat(val: string): boolean;
  * isNonNegativeFloat('abc') => false (non-numeric)
  *
  * @returns Returns `true` if the string is a non-negative float, `false` otherwise
- *
- * @remarks
- * - Accepts zero with decimal point (e.g., "0.0", "0.00")
- * - Accepts positive floats (e.g., "1.23", "999.5")
- * - Rejects negative floats (e.g., "-1.23", "-0.5")
- * - Rejects integers without decimal point (e.g., "7", "0")
- * - Rejects non-numeric strings (e.g., "abc", "1.2a")
  */
 declare function isNonNegativeFloat(val: string): boolean;
 /**
@@ -1117,13 +1205,6 @@ declare function isNonNegativeFloat(val: string): boolean;
  * isNegativeFloat('-7') => false (integer)
  *
  * @returns Returns `true` if the string is a negative float, `false` otherwise
- *
- * @remarks
- * - Accepts only negative floats less than zero (e.g., "-1.23", "-0.5")
- * - Rejects zero with decimal point (e.g., "0.0", "-0.0")
- * - Rejects positive floats (e.g., "1.23", "0.5")
- * - Rejects integers (e.g., "-7", "7")
- * - Rejects non-numeric strings (e.g., "abc", "-1.2a")
  */
 declare function isNegativeFloat(val: string): boolean;
 /**
@@ -1143,13 +1224,6 @@ declare function isNegativeFloat(val: string): boolean;
  * isNonPositiveFloat('abc') => false (non-numeric)
  *
  * @returns Returns `true` if the string is a non-positive float, `false` otherwise
- *
- * @remarks
- * - Accepts zero with decimal point (e.g., "0.0", "-0.0")
- * - Accepts negative floats (e.g., "-1.23", "-999.5")
- * - Rejects positive floats (e.g., "1.23", "0.5")
- * - Rejects integers without decimal point (e.g., "-7", "0")
- * - Rejects non-numeric strings (e.g., "abc", "-1.2a")
  */
 declare function isNonPositiveFloat(val: string): boolean;
 
@@ -1171,14 +1245,6 @@ declare function isNonPositiveFloat(val: string): boolean;
  * isInteger('abc') => false (non-numeric)
  *
  * @returns Returns `true` if the string is a valid integer, `false` otherwise
- *
- * @remarks
- * - Accepts positive integers (e.g., "1", "123", "999")
- * - Accepts negative integers (e.g., "-1", "-123", "-999")
- * - Accepts zero as "0"
- * - Rejects decimal numbers (e.g., "1.5", "-2.3")
- * - Rejects numbers with leading zeros (e.g., "01", "-02")
- * - Rejects non-numeric strings (e.g., "abc", "12a")
  */
 declare function isInteger(val: string): boolean;
 /**
@@ -1198,14 +1264,6 @@ declare function isInteger(val: string): boolean;
  * isPositiveInteger('1.5') => false (decimal)
  *
  * @returns Returns `true` if the string is a positive integer, `false` otherwise
- *
- * @remarks
- * - Accepts only positive integers greater than zero (e.g., "1", "123", "999")
- * - Rejects zero ("0")
- * - Rejects negative integers (e.g., "-1", "-123")
- * - Rejects decimal numbers (e.g., "1.5", "2.0")
- * - Rejects numbers with leading zeros (e.g., "01", "02")
- * - Rejects non-numeric strings (e.g., "abc", "12a")
  */
 declare function isPositiveInteger(val: string): boolean;
 /**
@@ -1225,15 +1283,6 @@ declare function isPositiveInteger(val: string): boolean;
  * isNonNegativeInteger('01') => false (leading zero)
  *
  * @returns Returns `true` if the string is a non-negative integer, `false` otherwise
- *
- * @remarks
- * - Accepts zero ("0")
- * - Accepts positive integers (e.g., "1", "123", "999")
- * - Rejects negative integers (e.g., "-1", "-123")
- * - Rejects decimal numbers (e.g., "1.5", "-2.3")
- * - Rejects numbers with leading zeros (e.g., "01", "02")
- * - Handles negative zero (-0) correctly by rejecting it
- * - Rejects non-numeric strings (e.g., "abc", "12a")
  */
 declare function isNonNegativeInteger(val: string): boolean;
 /**
@@ -1253,14 +1302,6 @@ declare function isNonNegativeInteger(val: string): boolean;
  * isNegativeInteger('-1.5') => false (decimal)
  *
  * @returns Returns `true` if the string is a negative integer, `false` otherwise
- *
- * @remarks
- * - Accepts only negative integers less than zero (e.g., "-1", "-123", "-999")
- * - Rejects zero ("0")
- * - Rejects positive integers (e.g., "1", "123")
- * - Rejects decimal numbers (e.g., "-1.5", "2.3")
- * - Rejects numbers with leading zeros (e.g., "-01", "-02")
- * - Rejects non-numeric strings (e.g., "abc", "-12a")
  */
 declare function isNegativeInteger(val: string): boolean;
 /**
@@ -1280,96 +1321,160 @@ declare function isNegativeInteger(val: string): boolean;
  * isNonPositiveInteger('-01') => false (leading zero)
  *
  * @returns Returns `true` if the string is a non-positive integer, `false` otherwise
- *
- * @remarks
- * - Accepts zero ("0")
- * - Accepts negative integers (e.g., "-1", "-123", "-999")
- * - Rejects positive integers (e.g., "1", "123")
- * - Rejects decimal numbers (e.g., "-1.5", "2.3")
- * - Rejects numbers with leading zeros (e.g., "-01", "-02")
- * - Handles negative zero (-0) correctly by accepting it
- * - Rejects non-numeric strings (e.g., "abc", "-12a")
  */
 declare function isNonPositiveInteger(val: string): boolean;
 
 /**
- * Checks if a string represents a valid standard decimal number.
+ * Validates whether a string represents a valid date in the specified format.
  *
- * This utility validates whether the input string matches standard decimal number format.
- * It uses strict regex pattern matching to ensure only valid decimal numbers are accepted.
- * The function also ensures the number is within JavaScript's safe integer range.
+ * This utility uses Day.js library with strict parsing mode to validate date strings
+ * against a given format. It ensures the date string exactly matches the format
+ * and represents a valid calendar date.
  *
  * @example
- * isStringNumber('123')        // true
- * isStringNumber('-45.67')     // true
- * isStringNumber('0')          // true
+ * isDateString('2023-01-01 12:30:45')  // => true
+ * isDateString('2024-02-29 00:00:00')  // => true (leap year)
+ * isDateString('2023-06-15', 'YYYY-MM-DD')  // => true
  *
  * @example
- * isStringNumber('.5')         // false (must start with digit)
- * isStringNumber('123.')       // false (must not end with dot)
- * isStringNumber('  42  ')     // false (contains spaces)
- * isStringNumber('1e5')        // false (scientific notation)
- * isStringNumber('0xFF')       // false (hexadecimal)
- * isStringNumber('abc')        // false (non-numeric)
- * isStringNumber('')           // false (empty)
+ * isDateString('2023-13-01 00:00:00')  // => false (invalid month)
+ * isDateString('2023-02-30 00:00:00')  // => false (invalid date)
+ * isDateString('2023/01/01 12:30:45')  // => false (wrong format)
  *
- * @returns Returns `true` if the string is a valid standard decimal number, `false` otherwise
+ * @returns Returns `true` if the string is a valid date in the specified format, `false` otherwise
  *
- * @remarks
- * - Only accepts standard decimal format: digits with optional decimal point
- * - Must start with a digit (optionally preceded by minus sign)
- * - If decimal point is present, must be followed by at least one digit
- * - Does not accept strings with leading or trailing whitespace
- * - Returns `false` for empty strings
- * - Ensures the number is within JavaScript's safe integer range
- * - Returns `false` for non-string inputs
+ * @see https://day.js.org/docs/en/parse/string-format
  */
-declare const isStringNumber: (val: string) => boolean;
+declare function isDateString(val: string, format?: string): boolean;
 
 /**
- * Validates whether the value is a mobile phone number.
+ * Validates whether a string represents a valid email address.
+ *
+ * This utility checks if the input string matches a valid email address format
+ * using a comprehensive regex pattern. It validates both the local part (before @)
+ * and the domain part (after @) according to standard email formatting rules.
  *
  * @example
+ * isEmail('test@example.com')  // => true
+ * isEmail('user+tag@domain.org')  // => true
+ * isEmail('name.surname@company.co.uk')  // => true
  *
- * isMobilePhone('13912345678') => true
+ * @example
+ * isEmail('invalid@')  // => false (missing domain)
+ * isEmail('@example.com')  // => false (missing local part)
+ * isEmail('test@.com')  // => false (invalid domain format)
  *
- * isMobilePhone('1381234567') => false
+ * @returns Returns `true` if the string is a valid email address, `false` otherwise
  */
-declare function isMobilePhone(val: string): boolean;
+declare function isEmail(val: string): boolean;
+
 /**
- * Validates whether the value is a URL.
+ * Validates whether a value is an empty string.
+ *
+ * This utility performs a strict equality check to determine if the input value
+ * is exactly an empty string (''), excluding other falsy values like null, undefined,
+ * or whitespace-only strings.
  *
  * @example
+ * isEmptyString('')  // => true
  *
- * isURL('https://example.com') => true
+ * @example
+ * isEmptyString(' ')  // => false (whitespace)
+ * isEmptyString(null)  // => false (null value)
+ * isEmptyString(undefined)  // => false (undefined value)
+ * isEmptyString(0)  // => false (number zero)
  *
- * isURL('htt://321') => false
+ * @returns Returns `true` if the value is exactly an empty string, `false` otherwise
  */
-declare function isURL(val: string): boolean;
+declare function isEmptyString(val: unknown): val is "";
+
 /**
- * Validates whether the value is an email address.
+ * Validates whether a string represents a valid Chinese ID card number.
+ *
+ * This utility validates Chinese national identification numbers (18 digits) by checking
+ * both the format pattern and the embedded date validity. It verifies the administrative
+ * division code, birth date format, and ensures the birth date is in the past.
  *
  * @example
+ * isIdCard('11010519491231002X')  // => true
+ * isIdCard('110105194912310021')  // => true
+ * isIdCard('320102198001010011')  // => true
  *
- * isEmail('test@example.com') => true
+ * @example
+ * isIdCard('01010519491231002X')  // => false (invalid admin code)
+ * isIdCard('11010519491231002')  // => false (incorrect length)
+ * isIdCard('110105199202300021')  // => false (invalid date - Feb 30th)
  *
- * isEmail('invalid@') => false
+ * @returns Returns `true` if the string is a valid Chinese ID card number, `false` otherwise
  */
-declare function isEmail(val: string): boolean;
+declare function isIdCard(val: string): boolean;
+
 /**
- * Validates whether the value is a empty string.
+ * Validates whether a string represents a valid Chinese mobile phone number.
+ *
+ * This utility checks if the input string matches the Chinese mobile phone number format,
+ * which must start with 1 followed by a digit from 3-9, and contain exactly 11 digits total.
+ * It supports all major Chinese carriers including China Mobile, China Unicom, and China Telecom.
+ *
+ * @example
+ * isMobilePhone('13912345678')  // => true
+ * isMobilePhone('16600001111')  // => true
+ * isMobilePhone('19955556666')  // => true
+ *
+ * @example
+ * isMobilePhone('1381234567')  // => false (too short)
+ * isMobilePhone('22345678901')  // => false (invalid prefix)
+ * isMobilePhone('138-1234-5678')  // => false (contains separators)
+ *
+ * @returns Returns `true` if the string is a valid Chinese mobile phone number, `false` otherwise
+ *
  */
-declare function isEmptyString(val: unknown): val is "";
+declare function isMobilePhone(val: string): boolean;
+
 /**
- * Validates if the value is a valid date string
- * @param format Date format
- * @default 'YYYY-MM-DD HH:mm:ss'
- * @see https://day.js.org/docs/zh-CN/parse/string-format
+ * Checks if a string represents a valid standard decimal number.
+ *
+ * This utility validates whether the input string matches standard decimal number format.
+ * It uses strict regex pattern matching to ensure only valid decimal numbers are accepted.
+ * The function also ensures the number is within JavaScript's safe integer range.
+ *
+ * @example
+ * isStringNumber('123')        // true
+ * isStringNumber('-13.67')     // true
+ * isStringNumber('0')          // true
+ *
+ * @example
+ * isStringNumber('.5')         // false (must start with digit)
+ * isStringNumber('123.')       // false (must not end with dot)
+ * isStringNumber('  42  ')     // false (contains spaces)
+ * isStringNumber('1e5')        // false (scientific notation)
+ * isStringNumber('0xFF')       // false (hexadecimal)
+ * isStringNumber('abc')        // false (non-numeric)
+ * isStringNumber('')           // false (empty)
+ *
+ * @returns Returns `true` if the string is a valid standard decimal number, `false` otherwise
  */
-declare function isDateString(val: string, format?: string): boolean;
+declare const isStringNumber: (val: string) => boolean;
+
 /**
- * Validates if the value is a valid Chinese ID card number
+ * Validates whether a string represents a valid URL.
+ *
+ * This utility checks if the input string matches a valid HTTP or HTTPS URL format.
+ * It uses a strict validation pattern that requires a proper protocol and domain structure.
+ * The validation is case-insensitive and supports various URL components like paths, queries, and ports.
+ *
+ * @example
+ * isURL('https://example.com')  // => true
+ * isURL('https://t-example.com:10086')  // => true
+ * isURL('https://www.example.com/path?query=param')  // => true
+ *
+ * @example
+ * isURL('ftp://example.com')  // => false (unsupported protocol)
+ * isURL('example.com')  // => false (missing protocol)
+ * isURL('https://')  // => false (missing domain)
+ *
+ * @returns Returns `true` if the string is a valid HTTP/HTTPS URL, `false` otherwise
  */
-declare function isIdCard(val: string): boolean;
+declare function isURL(val: string): boolean;
 
-export { type AnyObject, type ArrayItem, type Arrayable, type DeepMergeOptions, type PlainObject, type StringNumber, type StringifyOptions, UtilsError, type WithRetryOptions, base64Decode, base64Encode, castArray, compose, composeRight, debounce, debugWarn, debugWarnInvalidTypeMessage, decimalToBinary, deepClone, deepMerge, deprecated, generateRandomArray, generateRandomColor, generateRandomDate, generateRandomEmail, generateRandomFloat, generateRandomIdCard, generateRandomMobilePhone, generateRandomStringFromSource, getRandomInt, getRandomItem, getRandomString, getRandomUrl, hasChanged, hasCircularReference, isArray, isBoolean, isChineseString, isDate, isDateString, isDef, isEmail, isEmptyString, isEnglishAphabet, isFloat, isFunction, isIdCard, isInteger, isLowerCase, isLowerCaseAndNumber, isLowerCaseAndNumberAndChinese, isMap, isMobilePhone, isNegativeFloat, isNegativeInteger, isNil, isNonNegativeFloat, isNonNegativeInteger, isNonPositiveFloat, isNonPositiveInteger, isNull, isNumber, isNumberOrNumberString, isObject, isObjectLike, isPlainObject, isPositiveFloat, isPositiveInteger, isPromise, isRegExp, isSet, isString, isStringNumber, isSymbol, isURL, isUndef, isUpperCase, isUpperCaseAndNumber, isUpperCaseAndNumberAndChinese, objectToString, omit, pick, qs, qsStringify, throttle, throwError, throwErrorInvalidTypeMessage, toTypeString, toTypeValue, validatorChineseOrEnglish, validatorChineseOrEnglishOrNumber, validatorUppercaseOrNumbersOrSpecial, validatorUppercaseOrNumbersOrUnderline, withRetry };
+export { type AnyObject, type ArrayItem, type Arrayable, type DeepMergeOptions, type PlainObject, type StringNumber, type StringifyOptions, UtilsError, type WithRetryOptions, base64Decode, base64Encode, castArray, compose, composeRight, debounce, debugWarn, decimalToBinary, deepClone, deepMerge, generateRandomArray, generateRandomColor, generateRandomDate, generateRandomEmail, generateRandomFloat, generateRandomIdCard, generateRandomMobilePhone, generateRandomStringFromSource, getRandomInt, getRandomItem, getRandomString, getRandomUrl, hasChanged, hasCircularReference, isArray, isBoolean, isDate, isDateString, isDef, isEmail, isEmptyString, isFloat, isFunction, isIdCard, isInteger, isMap, isMobilePhone, isNegativeFloat, isNegativeInteger, isNil, isNonNegativeFloat, isNonNegativeInteger, isNonPositiveFloat, isNonPositiveInteger, isNull, isNumber, isObject, isObjectLike, isPlainObject, isPositiveFloat, isPositiveInteger, isPromise, isRegExp, isSet, isString, isStringNumber, isSymbol, isURL, isUndef, objectToString, omit, pick, qs, qsStringify, throttle, throwError, toTypeString, toTypeValue, withRetry };