@xxanderwp/jstoolkit 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,956 @@
+/**
+ * Generate a random string of specified length
+ * @param length - Length of the string to generate
+ * @param characters - Characters to use (default: alphanumeric)
+ * @returns Random string
+ */
+declare function randomString(length: number, characters?: string): string;
+/**
+ * Truncate a string to a specified length and add ellipsis
+ * @param str - String to truncate
+ * @param maxLength - Maximum length
+ * @param ellipsis - Ellipsis string (default: '...')
+ * @returns Truncated string
+ */
+declare function truncate(str: string, maxLength: number, ellipsis?: string): string;
+/**
+ * Capitalize the first letter of a string
+ * @param str - String to capitalize
+ * @returns Capitalized string
+ */
+declare function capitalize(str: string): string;
+/**
+ * Convert string to camelCase
+ * @param str - String to convert
+ * @returns camelCase string
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Convert string to snake_case
+ * @param str - String to convert
+ * @returns snake_case string
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Convert string to kebab-case
+ * @param str - String to convert
+ * @returns kebab-case string
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Remove all whitespace from a string
+ * @param str - String to process
+ * @returns String without whitespace
+ */
+declare function removeWhitespace(str: string): string;
+/**
+ * Count occurrences of a substring in a string
+ * @param str - String to search in
+ * @param substring - Substring to count
+ * @returns Number of occurrences
+ */
+declare function countOccurrences(str: string, substring: string): number;
+
+declare const string_capitalize: typeof capitalize;
+declare const string_countOccurrences: typeof countOccurrences;
+declare const string_randomString: typeof randomString;
+declare const string_removeWhitespace: typeof removeWhitespace;
+declare const string_toCamelCase: typeof toCamelCase;
+declare const string_toKebabCase: typeof toKebabCase;
+declare const string_toSnakeCase: typeof toSnakeCase;
+declare const string_truncate: typeof truncate;
+declare namespace string {
+  export {
+    string_capitalize as capitalize,
+    string_countOccurrences as countOccurrences,
+    string_randomString as randomString,
+    string_removeWhitespace as removeWhitespace,
+    string_toCamelCase as toCamelCase,
+    string_toKebabCase as toKebabCase,
+    string_toSnakeCase as toSnakeCase,
+    string_truncate as truncate,
+  };
+}
+
+/**
+ * Get a random element from an array
+ * @param arr - Array to pick from
+ * @returns Random element
+ */
+declare function randomElement<T>(arr: T[]): T;
+/**
+ * Get a random index from an array
+ * @param arr - Array to pick from
+ * @returns Random index
+ */
+declare function randomElementIndex<T>(arr: T[]): number;
+/**
+ * Shuffle an array using Fisher-Yates algorithm
+ * @param arr - Array to shuffle
+ * @returns Shuffled array (new array)
+ */
+declare function shuffle<T>(arr: T[]): T[];
+/**
+ * Split an array into chunks of specified size
+ * @param array - Array to chunk
+ * @param size - Size of each chunk
+ * @returns Array of chunks
+ */
+declare function chunk<T>(array: T[], size: number): T[][];
+/**
+ * Remove duplicate values from an array
+ * @param arr - Array to deduplicate
+ * @returns Array without duplicates
+ */
+declare function unique<T>(arr: T[]): T[];
+/**
+ * Get the intersection of two arrays
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Intersection array
+ */
+declare function intersection<T>(arr1: T[], arr2: T[]): T[];
+/**
+ * Get the difference of two arrays (elements in arr1 but not in arr2)
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Difference array
+ */
+declare function difference<T>(arr1: T[], arr2: T[]): T[];
+/**
+ * Sort array in ascending or descending order
+ * @param array - Array to sort
+ * @param order - Sort order ('ASC' or 'DESC')
+ * @returns Sorted array
+ */
+declare function sort<T>(array: T[], order?: 'ASC' | 'DESC'): T[];
+/**
+ * Sort array of objects by multiple properties
+ * @param array - Array to sort
+ * @param params - Sort parameters
+ * @returns Sorted array
+ */
+declare function sortBy<T>(array: T[], params: Array<{
+    key: keyof T;
+    order: 'ASC' | 'DESC';
+}>): T[];
+/**
+ * Sort array items by key order priority
+ * @param items - Array to sort
+ * @param keyOrder - Priority order of keys
+ * @returns Sorted array
+ */
+declare function sortByKeys(items: string[], keyOrder: string[]): string[];
+/**
+ * Group array elements by a key function
+ * @param arr - Array to group
+ * @param keyFn - Function that returns the group key
+ * @returns Object with grouped elements
+ */
+declare function groupBy<T>(arr: T[], keyFn: (item: T) => string | number): Record<string | number, T[]>;
+/**
+ * Flatten nested arrays to specified depth
+ * @param arr - Array to flatten
+ * @param depth - Depth to flatten (default: 1)
+ * @returns Flattened array
+ */
+declare function flatten$1<T>(arr: unknown[], depth?: number): T[];
+
+declare const array_chunk: typeof chunk;
+declare const array_difference: typeof difference;
+declare const array_groupBy: typeof groupBy;
+declare const array_intersection: typeof intersection;
+declare const array_randomElement: typeof randomElement;
+declare const array_randomElementIndex: typeof randomElementIndex;
+declare const array_shuffle: typeof shuffle;
+declare const array_sort: typeof sort;
+declare const array_sortBy: typeof sortBy;
+declare const array_sortByKeys: typeof sortByKeys;
+declare const array_unique: typeof unique;
+declare namespace array {
+  export {
+    array_chunk as chunk,
+    array_difference as difference,
+    flatten$1 as flatten,
+    array_groupBy as groupBy,
+    array_intersection as intersection,
+    array_randomElement as randomElement,
+    array_randomElementIndex as randomElementIndex,
+    array_shuffle as shuffle,
+    array_sort as sort,
+    array_sortBy as sortBy,
+    array_sortByKeys as sortByKeys,
+    array_unique as unique,
+  };
+}
+
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+declare function randomInt$1(min: number, max: number): number;
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ */
+declare function randomFloat$1(min: number, max: number): number;
+/**
+ * Round a number to specified decimal places
+ * @param value - Value to round
+ * @param decimals - Number of decimal places
+ * @param mode - Rounding mode ('round' or 'truncate')
+ * @returns Rounded number
+ */
+declare function round(value: number, decimals: number, mode?: 'round' | 'truncate'): number;
+/**
+ * Linear interpolation between two values
+ * @param start - Start value
+ * @param end - End value
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated value
+ */
+declare function lerp(start: number, end: number, amount: number): number;
+/**
+ * Linear interpolation between two 2D points
+ * @param point1 - First point
+ * @param point2 - Second point
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated point
+ */
+declare function lerp2D(point1: {
+    x: number;
+    y: number;
+}, point2: {
+    x: number;
+    y: number;
+}, amount: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Linear interpolation between two 3D vectors
+ * @param vec1 - First vector
+ * @param vec2 - Second vector
+ * @param amount - Interpolation amount (0-1)
+ * @returns Interpolated vector
+ */
+declare function lerp3D(vec1: {
+    x: number;
+    y: number;
+    z: number;
+}, vec2: {
+    x: number;
+    y: number;
+    z: number;
+}, amount: number): {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * Calculate time-based interpolation value
+ * @param start - Start timestamp
+ * @param end - End timestamp
+ * @param current - Current timestamp (default: Date.now())
+ * @returns Interpolation value (0-1)
+ */
+declare function lerpTime(start: number, end: number, current?: number): number;
+/**
+ * Clamp a value between min and max
+ * @param value - Value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ */
+declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Map a value from one range to another
+ * @param value - Value to map
+ * @param inMin - Input range minimum
+ * @param inMax - Input range maximum
+ * @param outMin - Output range minimum
+ * @param outMax - Output range maximum
+ * @returns Mapped value
+ */
+declare function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/**
+ * Calculate percentage
+ * @param value - Value
+ * @param total - Total value
+ * @returns Percentage (0-100)
+ */
+declare function percentage(value: number, total: number): number;
+/**
+ * Calculate average of numbers
+ * @param numbers - Array of numbers
+ * @returns Average value
+ */
+declare function average(numbers: number[]): number;
+/**
+ * Calculate sum of numbers
+ * @param numbers - Array of numbers
+ * @returns Sum
+ */
+declare function sum(numbers: number[]): number;
+/**
+ * Find minimum value in array
+ * @param numbers - Array of numbers
+ * @returns Minimum value
+ */
+declare function min(numbers: number[]): number;
+/**
+ * Find maximum value in array
+ * @param numbers - Array of numbers
+ * @returns Maximum value
+ */
+declare function max(numbers: number[]): number;
+
+declare const math_average: typeof average;
+declare const math_clamp: typeof clamp;
+declare const math_lerp: typeof lerp;
+declare const math_lerp2D: typeof lerp2D;
+declare const math_lerp3D: typeof lerp3D;
+declare const math_lerpTime: typeof lerpTime;
+declare const math_mapRange: typeof mapRange;
+declare const math_max: typeof max;
+declare const math_min: typeof min;
+declare const math_percentage: typeof percentage;
+declare const math_round: typeof round;
+declare const math_sum: typeof sum;
+declare namespace math {
+  export {
+    math_average as average,
+    math_clamp as clamp,
+    math_lerp as lerp,
+    math_lerp2D as lerp2D,
+    math_lerp3D as lerp3D,
+    math_lerpTime as lerpTime,
+    math_mapRange as mapRange,
+    math_max as max,
+    math_min as min,
+    math_percentage as percentage,
+    randomFloat$1 as randomFloat,
+    randomInt$1 as randomInt,
+    math_round as round,
+    math_sum as sum,
+  };
+}
+
+/**
+ * Get current Unix timestamp in seconds
+ * @returns Current timestamp
+ */
+declare function timestamp(): number;
+/**
+ * Get current Unix timestamp in milliseconds
+ * @returns Current timestamp in ms
+ */
+declare function timestampMs(): number;
+/**
+ * Format a number with leading zero
+ * @param num - Number to format
+ * @returns Formatted string
+ */
+declare function padZero(num: number | string): string;
+/**
+ * Get full date and time string
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY HH:MM)
+ */
+declare function formatDateTime(date?: Date): string;
+/**
+ * Get full date and time string with seconds
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY HH:MM:SS)
+ */
+declare function formatDateTimeSeconds(date?: Date): string;
+/**
+ * Get date without time
+ * @param date - Date object (default: current date)
+ * @returns Formatted date string (DD.MM.YYYY)
+ */
+declare function formatDate(date?: Date): string;
+/**
+ * Format timestamp to readable date/time string
+ * Shows only time if date is today, otherwise shows date and time
+ * @param time - Unix timestamp in seconds (default: current time)
+ * @param alwaysShowDate - Always show date even if today
+ * @returns Formatted string
+ */
+declare function formatTimestamp(time?: number, alwaysShowDate?: boolean): string;
+/**
+ * Convert seconds to formatted duration string (HH:MM:SS or D:HH:MM:SS)
+ * @param seconds - Duration in seconds
+ * @returns Formatted duration string
+ */
+declare function formatDuration(seconds: number): string;
+/**
+ * Convert milliseconds to formatted duration string with ms
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string (HH:MM:SS.mmm)
+ */
+declare function formatDurationMs(ms: number): string;
+/**
+ * Sleep/delay for specified milliseconds
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after delay
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Check if a date is today
+ * @param date - Date to check
+ * @returns True if date is today
+ */
+declare function isToday(date: Date): boolean;
+/**
+ * Check if a date is yesterday
+ * @param date - Date to check
+ * @returns True if date is yesterday
+ */
+declare function isYesterday(date: Date): boolean;
+/**
+ * Get relative time string (e.g., "2 hours ago", "in 3 days")
+ * @param date - Date to compare
+ * @param now - Reference date (default: current date)
+ * @returns Relative time string
+ */
+declare function timeAgo(date: Date, now?: Date): string;
+
+declare const time_formatDate: typeof formatDate;
+declare const time_formatDateTime: typeof formatDateTime;
+declare const time_formatDateTimeSeconds: typeof formatDateTimeSeconds;
+declare const time_formatDuration: typeof formatDuration;
+declare const time_formatDurationMs: typeof formatDurationMs;
+declare const time_formatTimestamp: typeof formatTimestamp;
+declare const time_isToday: typeof isToday;
+declare const time_isYesterday: typeof isYesterday;
+declare const time_padZero: typeof padZero;
+declare const time_sleep: typeof sleep;
+declare const time_timeAgo: typeof timeAgo;
+declare const time_timestamp: typeof timestamp;
+declare const time_timestampMs: typeof timestampMs;
+declare namespace time {
+  export {
+    time_formatDate as formatDate,
+    time_formatDateTime as formatDateTime,
+    time_formatDateTimeSeconds as formatDateTimeSeconds,
+    time_formatDuration as formatDuration,
+    time_formatDurationMs as formatDurationMs,
+    time_formatTimestamp as formatTimestamp,
+    time_isToday as isToday,
+    time_isYesterday as isYesterday,
+    time_padZero as padZero,
+    time_sleep as sleep,
+    time_timeAgo as timeAgo,
+    time_timestamp as timestamp,
+    time_timestampMs as timestampMs,
+  };
+}
+
+/**
+ * Encode string to Base64
+ * @param str - String to encode
+ * @returns Base64 encoded string
+ */
+declare function toBase64(str: string): string;
+/**
+ * Decode Base64 string
+ * @param encoded - Base64 encoded string
+ * @returns Decoded string
+ */
+declare function fromBase64(encoded: string): string;
+/**
+ * Generate MD5 hash of a string
+ * @param text - Text to hash
+ * @returns MD5 hash
+ */
+declare function hash(text: string): string;
+/**
+ * Encode URI component safely
+ * @param str - String to encode
+ * @returns Encoded URI component
+ */
+declare function encodeUri(str: string): string;
+/**
+ * Decode URI component safely
+ * @param str - String to decode
+ * @returns Decoded URI component
+ */
+declare function decodeUri(str: string): string;
+/**
+ * Convert ArrayBuffer to Buffer (Node.js)
+ * @param ab - ArrayBuffer to convert
+ * @returns Buffer
+ */
+declare function arrayBufferToBuffer(ab: ArrayBuffer): Buffer;
+/**
+ * Convert hex string to bytes
+ * @param hex - Hex string
+ * @returns Uint8Array
+ */
+declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * Convert bytes to hex string
+ * @param bytes - Byte array
+ * @returns Hex string
+ */
+declare function bytesToHex(bytes: Uint8Array): string;
+
+declare const encoding_arrayBufferToBuffer: typeof arrayBufferToBuffer;
+declare const encoding_bytesToHex: typeof bytesToHex;
+declare const encoding_decodeUri: typeof decodeUri;
+declare const encoding_encodeUri: typeof encodeUri;
+declare const encoding_fromBase64: typeof fromBase64;
+declare const encoding_hash: typeof hash;
+declare const encoding_hexToBytes: typeof hexToBytes;
+declare const encoding_toBase64: typeof toBase64;
+declare namespace encoding {
+  export {
+    encoding_arrayBufferToBuffer as arrayBufferToBuffer,
+    encoding_bytesToHex as bytesToHex,
+    encoding_decodeUri as decodeUri,
+    encoding_encodeUri as encodeUri,
+    encoding_fromBase64 as fromBase64,
+    encoding_hash as hash,
+    encoding_hexToBytes as hexToBytes,
+    encoding_toBase64 as toBase64,
+  };
+}
+
+/**
+ * Check if a string is a valid emoji
+ * @param str - String to check
+ * @returns True if string is an emoji
+ */
+declare function isEmoji(str: string): boolean;
+/**
+ * Check if a URL is an image link
+ * @param url - URL to check
+ * @returns True if URL points to an image
+ */
+declare function isImageUrl(url: string): boolean;
+/**
+ * Check if a string is a valid email
+ * @param email - Email string to validate
+ * @returns True if email is valid
+ */
+declare function isEmail(email: string): boolean;
+/**
+ * Check if a string is a valid URL
+ * @param url - URL string to validate
+ * @returns True if URL is valid
+ */
+declare function isUrl(url: string): boolean;
+/**
+ * Check if a string contains only numbers
+ * @param str - String to check
+ * @returns True if string contains only numbers
+ */
+declare function isNumeric(str: string): boolean;
+/**
+ * Check if a string contains only letters
+ * @param str - String to check
+ * @returns True if string contains only letters
+ */
+declare function isAlpha(str: string): boolean;
+/**
+ * Check if a string contains only letters and numbers
+ * @param str - String to check
+ * @returns True if string is alphanumeric
+ */
+declare function isAlphanumeric(str: string): boolean;
+/**
+ * Check if a value is empty (null, undefined, empty string, empty array, empty object)
+ * @param value - Value to check
+ * @returns True if value is empty
+ */
+declare function isEmpty(value: unknown): value is null | undefined | '' | [] | Record<string, never>;
+/**
+ * Check if a value is a plain object
+ * @param value - Value to check
+ * @returns True if value is a plain object
+ */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Extract URL information from a string
+ * @param str - String containing URL
+ * @returns URL info or null if no URL found
+ */
+declare function extractUrl(str: string): {
+    url: string;
+    domain: string;
+} | null;
+/**
+ * Check if a string is a valid IPv4 address
+ * @param ip - IP address string
+ * @returns True if valid IPv4
+ */
+declare function isIPv4(ip: string): boolean;
+/**
+ * Check if a string is a valid hex color
+ * @param color - Color string
+ * @returns True if valid hex color
+ */
+declare function isHexColor(color: string): boolean;
+
+declare const validation_extractUrl: typeof extractUrl;
+declare const validation_isAlpha: typeof isAlpha;
+declare const validation_isAlphanumeric: typeof isAlphanumeric;
+declare const validation_isEmail: typeof isEmail;
+declare const validation_isEmoji: typeof isEmoji;
+declare const validation_isEmpty: typeof isEmpty;
+declare const validation_isHexColor: typeof isHexColor;
+declare const validation_isIPv4: typeof isIPv4;
+declare const validation_isImageUrl: typeof isImageUrl;
+declare const validation_isNumeric: typeof isNumeric;
+declare const validation_isPlainObject: typeof isPlainObject;
+declare const validation_isUrl: typeof isUrl;
+declare namespace validation {
+  export {
+    validation_extractUrl as extractUrl,
+    validation_isAlpha as isAlpha,
+    validation_isAlphanumeric as isAlphanumeric,
+    validation_isEmail as isEmail,
+    validation_isEmoji as isEmoji,
+    validation_isEmpty as isEmpty,
+    validation_isHexColor as isHexColor,
+    validation_isIPv4 as isIPv4,
+    validation_isImageUrl as isImageUrl,
+    validation_isNumeric as isNumeric,
+    validation_isPlainObject as isPlainObject,
+    validation_isUrl as isUrl,
+  };
+}
+
+/**
+ * Format a number with thousands separators
+ * @param num - Number to format
+ * @param removeTrailingZeros - Remove .00 from integers (default: true)
+ * @returns Formatted number string
+ */
+declare function formatNumber(num: number, removeTrailingZeros?: boolean): string;
+/**
+ * Format bytes to human-readable size
+ * @param bytes - Number of bytes
+ * @param decimals - Decimal places (default: 2)
+ * @returns Formatted size string
+ */
+declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Format a number as currency
+ * @param amount - Amount to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale for formatting (default: 'en-US')
+ * @returns Formatted currency string
+ */
+declare function formatCurrency(amount: number, currency?: string, locale?: string): string;
+/**
+ * Format a phone number (basic US format)
+ * @param phone - Phone number string
+ * @returns Formatted phone number
+ */
+declare function formatPhone(phone: string): string;
+/**
+ * Format a credit card number with spaces
+ * @param cardNumber - Card number string
+ * @returns Formatted card number
+ */
+declare function formatCardNumber(cardNumber: string): string;
+/**
+ * Mask sensitive data (show only last N characters)
+ * @param str - String to mask
+ * @param visibleChars - Number of visible characters at the end (default: 4)
+ * @param maskChar - Character to use for masking (default: '*')
+ * @returns Masked string
+ */
+declare function maskString(str: string, visibleChars?: number, maskChar?: string): string;
+/**
+ * Format percentage
+ * @param value - Value to format
+ * @param decimals - Decimal places (default: 2)
+ * @returns Formatted percentage string
+ */
+declare function formatPercentage(value: number, decimals?: number): string;
+/**
+ * Pluralize a word based on count
+ * @param count - Count number
+ * @param singular - Singular form
+ * @param plural - Plural form (optional, will add 's' if not provided)
+ * @returns Pluralized string with count
+ */
+declare function pluralize(count: number, singular: string, plural?: string): string;
+/**
+ * Abbreviate large numbers (1000 -> 1K, 1000000 -> 1M)
+ * @param num - Number to abbreviate
+ * @param decimals - Decimal places (default: 1)
+ * @returns Abbreviated number string
+ */
+declare function abbreviateNumber(num: number, decimals?: number): string;
+/**
+ * Format file name with extension
+ * @param name - File name without extension
+ * @param extension - File extension
+ * @returns Formatted file name
+ */
+declare function formatFileName(name: string, extension: string): string;
+/**
+ * Title case a string (capitalize first letter of each word)
+ * @param str - String to title case
+ * @returns Title cased string
+ */
+declare function titleCase(str: string): string;
+
+declare const format_abbreviateNumber: typeof abbreviateNumber;
+declare const format_formatBytes: typeof formatBytes;
+declare const format_formatCardNumber: typeof formatCardNumber;
+declare const format_formatCurrency: typeof formatCurrency;
+declare const format_formatFileName: typeof formatFileName;
+declare const format_formatNumber: typeof formatNumber;
+declare const format_formatPercentage: typeof formatPercentage;
+declare const format_formatPhone: typeof formatPhone;
+declare const format_maskString: typeof maskString;
+declare const format_pluralize: typeof pluralize;
+declare const format_titleCase: typeof titleCase;
+declare namespace format {
+  export {
+    format_abbreviateNumber as abbreviateNumber,
+    format_formatBytes as formatBytes,
+    format_formatCardNumber as formatCardNumber,
+    format_formatCurrency as formatCurrency,
+    format_formatFileName as formatFileName,
+    format_formatNumber as formatNumber,
+    format_formatPercentage as formatPercentage,
+    format_formatPhone as formatPhone,
+    format_maskString as maskString,
+    format_pluralize as pluralize,
+    format_titleCase as titleCase,
+  };
+}
+
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+declare function randomInt(min: number, max: number): number;
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ */
+declare function randomFloat(min: number, max: number): number;
+/**
+ * Generate a random boolean
+ * @param probability - Probability of true (0-1, default: 0.5)
+ * @returns Random boolean
+ */
+declare function randomBoolean(probability?: number): boolean;
+/**
+ * Pick N random unique elements from an array
+ * @param arr - Array to pick from
+ * @param count - Number of elements to pick
+ * @returns Array of random elements
+ */
+declare function randomSample<T>(arr: T[], count: number): T[];
+/**
+ * Generate a random hex color
+ * @returns Random hex color string
+ */
+declare function randomColor(): string;
+/**
+ * Generate a random UUID v4
+ * @returns UUID string
+ */
+declare function randomUUID(): string;
+/**
+ * Generate random weighted choice based on weights
+ * @param items - Array of items
+ * @param weights - Array of weights (must match items length)
+ * @returns Random item based on weights
+ */
+declare function randomWeighted<T>(items: T[], weights: number[]): T;
+/**
+ * Generate a random date between two dates
+ * @param start - Start date
+ * @param end - End date
+ * @returns Random date
+ */
+declare function randomDate(start: Date, end: Date): Date;
+
+declare const random_randomBoolean: typeof randomBoolean;
+declare const random_randomColor: typeof randomColor;
+declare const random_randomDate: typeof randomDate;
+declare const random_randomFloat: typeof randomFloat;
+declare const random_randomInt: typeof randomInt;
+declare const random_randomSample: typeof randomSample;
+declare const random_randomUUID: typeof randomUUID;
+declare const random_randomWeighted: typeof randomWeighted;
+declare namespace random {
+  export {
+    random_randomBoolean as randomBoolean,
+    random_randomColor as randomColor,
+    random_randomDate as randomDate,
+    random_randomFloat as randomFloat,
+    random_randomInt as randomInt,
+    random_randomSample as randomSample,
+    random_randomUUID as randomUUID,
+    random_randomWeighted as randomWeighted,
+  };
+}
+
+/**
+ * Deep clone an object
+ * @param obj - Object to clone
+ * @returns Cloned object
+ */
+declare function deepClone<T>(obj: T): T;
+type PlainObject = Record<string, unknown>;
+/**
+ * Deep merge two or more objects (mutates target)
+ */
+declare function deepMerge<T extends PlainObject>(target: T, ...sources: PlainObject[]): T;
+/**
+ * Get nested property value from object using path
+ * @param obj - Object to get value from
+ * @param path - Property path (e.g., 'user.address.city')
+ * @param defaultValue - Default value if path not found
+ * @returns Property value or default
+ */
+declare function get<T = any>(obj: any, path: string, defaultValue?: T): T | undefined;
+/**
+ * Set nested property value in object using path
+ * @param obj - Object to set value in
+ * @param path - Property path (e.g., 'user.address.city')
+ * @param value - Value to set
+ * @returns Modified object
+ */
+declare function set<T extends Record<string, any>>(obj: T, path: string, value: any): T;
+/**
+ * Pick specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to pick
+ * @returns New object with picked properties
+ */
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Omit specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without omitted properties
+ */
+declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Flatten nested object to single level with dot notation keys
+ * @param obj - Object to flatten
+ * @param prefix - Key prefix (used internally)
+ * @returns Flattened object
+ */
+declare function flatten(obj: Record<string, any>, prefix?: string): Record<string, any>;
+/**
+ * Unflatten object with dot notation keys to nested object
+ * @param obj - Flattened object
+ * @returns Nested object
+ */
+declare function unflatten(obj: Record<string, any>): Record<string, any>;
+/**
+ * Get all keys from object including nested keys (dot notation)
+ * @param obj - Object to get keys from
+ * @param prefix - Key prefix (used internally)
+ * @returns Array of all keys
+ */
+declare function keys(obj: Record<string, any>, prefix?: string): string[];
+/**
+ * Get all values from object including nested values
+ * @param obj - Object to get values from
+ * @returns Array of all values
+ */
+declare function values(obj: Record<string, any>): any[];
+/**
+ * Check if two objects are deeply equal
+ * @param obj1 - First object
+ * @param obj2 - Second object
+ * @returns True if objects are equal
+ */
+declare function isEqual(obj1: any, obj2: any): boolean;
+
+declare const object_deepClone: typeof deepClone;
+declare const object_deepMerge: typeof deepMerge;
+declare const object_flatten: typeof flatten;
+declare const object_get: typeof get;
+declare const object_isEqual: typeof isEqual;
+declare const object_keys: typeof keys;
+declare const object_omit: typeof omit;
+declare const object_pick: typeof pick;
+declare const object_set: typeof set;
+declare const object_unflatten: typeof unflatten;
+declare const object_values: typeof values;
+declare namespace object {
+  export {
+    object_deepClone as deepClone,
+    object_deepMerge as deepMerge,
+    object_flatten as flatten,
+    object_get as get,
+    object_isEqual as isEqual,
+    object_keys as keys,
+    object_omit as omit,
+    object_pick as pick,
+    object_set as set,
+    object_unflatten as unflatten,
+    object_values as values,
+  };
+}
+
+declare const toolkit: {
+    string: typeof string;
+    array: typeof array;
+    math: typeof math;
+    time: typeof time;
+    encoding: typeof encoding;
+    validation: typeof validation;
+    format: typeof format;
+    random: typeof random;
+    object: typeof object;
+    randomString: typeof randomString;
+    capitalize: typeof capitalize;
+    truncate: typeof truncate;
+    randomElement: typeof randomElement;
+    chunk: typeof chunk;
+    unique: typeof unique;
+    shuffle: typeof shuffle;
+    randomInt: typeof randomInt$1;
+    randomFloat: typeof randomFloat$1;
+    lerp: typeof lerp;
+    clamp: typeof clamp;
+    round: typeof round;
+    timestamp: typeof timestamp;
+    timestampMs: typeof timestampMs;
+    formatDateTime: typeof formatDateTime;
+    formatDuration: typeof formatDuration;
+    sleep: typeof sleep;
+    toBase64: typeof toBase64;
+    fromBase64: typeof fromBase64;
+    hash: typeof hash;
+    isEmail: typeof isEmail;
+    isUrl: typeof isUrl;
+    isEmpty: typeof isEmpty;
+    isEmoji: typeof isEmoji;
+    formatNumber: typeof formatNumber;
+    formatBytes: typeof formatBytes;
+    pluralize: typeof pluralize;
+    randomBoolean: typeof randomBoolean;
+    randomColor: typeof randomColor;
+    randomUUID: typeof randomUUID;
+    deepClone: typeof deepClone;
+    pick: typeof pick;
+    omit: typeof omit;
+    get: typeof get;
+    set: typeof set;
+};
+
+export { array, capitalize, chunk, clamp, deepClone, toolkit as default, encoding, format, formatBytes, formatDateTime, formatDuration, formatNumber, fromBase64, get, hash, isEmail, isEmoji, isEmpty, isUrl, lerp, math, object, omit, pick, pluralize, random, randomBoolean, randomColor, randomElement, randomFloat$1 as randomFloat, randomInt$1 as randomInt, randomString, randomUUID, round, set, shuffle, sleep, string, time, timestamp, timestampMs, toBase64, unique, validation };