/**
 * 函数返回值
 */
export type HxzxUtilsFunctionReturn<T> = () => T;
/**
 * 发布订阅事件函数类型
 * @param parameter - 任意数量的参数
 * @returns 任意类型的返回值
 */
export type HxzxUtilsEventBusFunction = (...parameter: any[]) => any;
/**
 * 消息队列回调函数类型
 * @param parameter - 任意数量的参数
 * @returns 任意类型的返回值
 */
export type HxzxUtilsQueueCallbackFunction = (...parameter: any[]) => any;
/**
 * 存储单位类型
 */
export type HxzxUtilsStorageUnit = "B" | "KB" | "MB" | "GB" | "TB";
/**
 * 操作时间类型
 * - millisecond: 毫秒
 * - second: 秒
 * - minute: 分钟
 * - hour: 小时
 * - day: 天
 */
export type HxzxUtilsDateOperationType = "millisecond" | "second" | "minute" | "hour" | "day";
/**
 * 操作时间类型
 * - week: 周
 * - quarter: 季度
 * - month: 月
 * - year: 年
 */
export type HxzxUtilsDateOperationTypeAll = HxzxUtilsDateOperationType | "week" | "month" | "quarter" | "year";
/**
 * 时间工具扩展类型
 * 基于原生 Date 对象扩展，提供更多时间处理方法
 */
export type HxzxUtilsDateReturn = Date & {
    /**
     * 格式化日期时间
     *
     * 支持的格式化令牌：
     * | 令牌  | 示例     | 描述                    |
     * | :---- | :------- | :---------------------- |
     * | `YY`  | 18       | 两位数的年份            |
     * | `YYYY`| 2018     | 四位数的年份            |
     * | `M`   | 1-12     | 月份，从 1 开始         |
     * | `MM`  | 01-12    | 月份，两位数            |
     * | `D`   | 1-31     | 月份里的一天            |
     * | `DD`  | 01-31    | 月份里的一天，两位数    |
     * | `H`   | 0-23     | 小时 (24小时制)         |
     * | `HH`  | 00-23    | 小时，两位数 (24小时制) |
     * | `h`   | 1-12     | 小时 (12小时制)         |
     * | `hh`  | 01-12    | 小时，两位数 (12小时制) |
     * | `m`   | 0-59     | 分钟                    |
     * | `mm`  | 00-59    | 分钟，两位数            |
     * | `s`   | 0-59     | 秒                      |
     * | `ss`  | 00-59    | 秒，两位数              |
     * | `S`   | 0-9      | 毫秒，一位数            |
     * | `SS`  | 00-99    | 毫秒，两位数            |
     * | `SSS` | 000-999  | 毫秒，三位数            |
     *
     * @param f - 格式化规则字符串。若不传或格式错误，返回默认日期字符串
     * @returns 格式化后的时间字符串
     *
     * @example
     * hxzxUtils.date().format('YYYY-MM-DD HH:mm:ss'); // "2023-08-15 14:30:05"
     */
    format(f: string): string;
    /**
     * 累计时间
     *
     * 计算时间的累积值，常用于计算某个时间段包含的具体时间单位。
     *
     * 支持的类型：
     * | 类型           | 描述 |
     * | :------------- | :--- |
     * | `auto`         | 自动检测（根据时间长度自动选择最合适的展示单位） |
     * | `day`          | 天   |
     * | `hour`         | 小时 |
     * | `minute`       | 分钟 |
     * | `second`       | 秒   |
     * | `millisecond`  | 毫秒（直接返回总毫秒数） |
     *
     * @param {HxzxUtilsDateOperationType | "auto"} [type='auto'] - 格式化规则字符串（最大展示单位）。默认 'auto'（自动检测）
     * @param {Object} [config] - 自定义配置项
     * @param {string} [config.millisecond='毫秒'] - 毫秒单位。仅当 `isMs` 为 true 时有效
     * @param {string} [config.second='秒'] - 秒单位
     * @param {string} [config.minute='分钟'] - 分钟单位
     * @param {string} [config.hour='小时'] - 小时单位
     * @param {string} [config.day='天'] - 天单位
     * @param {boolean} [config.isComplete=false] - 是否补齐0（如 1分钟1秒 等于 1分钟01秒）。默认false。注意：首个非零单位不会补0
     * @param {boolean} [config.isMs=false] - 是否在结果中展示毫秒。默认false
     * @param {boolean} [config.isDowngrade=true] - 是否开启降级展示。默认true
     *
     * 例如 total('minute') 时不足1分钟，默认降级显示为 x秒；若为 false，则显示为 0分钟x秒
     *
     * 例如 total('minute') 时刚好满足分钟，默认降级显示为 x分钟；若为 false，则显示为 x分钟0秒
     *
     * @returns {string} 格式化后的累计时间字符串
     *
     * @example
     * // 基础用法（不足1分钟时，默认降级展示秒）
     * hxzxUtils.date(9000).total('minute'); // "9秒"
     * hxzxUtils.date(9000).total('minute', { isDowngrade: false }); // "0分钟9秒"
     * hxzxUtils.date(10000).total('minute'); // "10秒"
     * hxzxUtils.date(0).total('minute'); // "0秒"
     *
     * // 刚好达到或超过1分钟
     * hxzxUtils.date(60000).total('minute'); // "1分钟"
     * hxzxUtils.date(60000).total('minute', { isDowngrade: false }); // "1分钟0秒"
     * hxzxUtils.date(61000).total('minute'); // "1分钟1秒"
     *
     * // 自定义单位
     * hxzxUtils.date(61000).total('minute', { second: 's', minute: 'm' }); // "1m1s"
     *
     * // 补齐0（注意：首个单位不补0）
     * hxzxUtils.date(61100).total('minute', { second: 's', minute: 'm', isComplete: true }); // "1m01s"
     *
     * // 展示毫秒
     * hxzxUtils.date(61100).total('minute', { millisecond: 'ms', second: 's', minute: 'm', isComplete: true, isMs: true }); // "1m01s100ms"
     *
     * // 自动检测（auto）
     * hxzxUtils.date(9000).total('auto'); // "9秒"
     * hxzxUtils.date(60000).total('auto'); // "1分钟"
     * hxzxUtils.date(3600000).total('auto'); // "1小时"
     * hxzxUtils.date(86400000).total('auto'); // "1天"
     */
    total(type?: HxzxUtilsDateOperationType | "auto", config?: {
        millisecond?: string;
        second?: string;
        minute?: string;
        hour?: string;
        day?: string;
        isComplete?: boolean;
        isMs?: boolean;
        isDowngrade?: boolean;
    }): string;
    /**
     * 获取相对时间描述
     *
     * 根据时间差返回相对时间描述字符串，具体规则如下：
     * | 时间范围 | 返回格式 |
     * | :--- | :--- |
     * | `<` minSecond (默认10s) | "刚刚" |
     * | `<` 60s | "X秒前/后" |
     * | `<` 60m | "X分钟前/后" |
     * | `<` 24h | "X小时前/后" |
     * | `<` 30d | "X天前/后" |
     * | `<` 12月 | "X个月前/后" |
     * | `>=` 12月 | "X年前/后" |
     *
     * @param config - 配置项
     * @param config.minSecond - 阈值：小于多少秒视为"刚刚"。范围 0-59，默认 10，单位秒
     * @param config.contrastTime - 基准时间戳，用于对比。默认当前时间戳
     * @returns 相对时间描述字符串
     *
     * @example
     * hxzxUtils.date().ft(); // "刚刚"
     */
    ft(config?: {
        minSecond?: number;
        contrastTime?: number;
    }): string;
    /**
     * 增加时间
     *
     * @param type - 操作时间类型
     * @param value - 增加的时间值
     * @returns 返回时间操作函数，支持链式调用
     *
     * @example
     * hxzxUtils.date().add('day', 1).ft(); // "1天后"
     */
    add(type: HxzxUtilsDateOperationType, value: number): HxzxUtilsDateReturn;
    /**
     * 减少时间
     *
     * @param type - 操作时间类型
     * @param value - 减少的时间值
     * @returns 返回时间操作函数，支持链式调用
     *
     * @example
     * hxzxUtils.date().subtract('day', 1).ft(); // "1天前"
     */
    subtract(type: HxzxUtilsDateOperationType, value: number): HxzxUtilsDateReturn;
    /**
     * 获取指定时间单位的开始时间
     *
     * @param type - 操作时间类型
     * @returns 返回时间操作函数，支持链式调用
     *
     * @example
     * hxzxUtils.date().startOf('day').format('YYYY-MM-DD HH:mm:ss'); // "xxxx-xx-xx 00:00:00"
     *
     * @example
     * // 还可以判断时间是否相等 hxzxUtils.date().endOf同理
     * hxzxUtils.date('2026-01-01 44:44:44').startOf('day').valueOf() === hxzxUtils.date('2026-01-01 44:44:44').startOf('day').valueOf(); // 表示是否同一天
     * hxzxUtils.date('2026-01-01 44:44:44').startOf('year').valueOf() === hxzxUtils.date('2026-01-01 44:44:44').startOf('year').valueOf(); // 表示是否同一年
     */
    startOf(type: HxzxUtilsDateOperationTypeAll): HxzxUtilsDateReturn;
    /**
     * 获取指定时间单位的结束时间
     *
     * @param type - 操作时间类型
     * @returns 返回时间操作函数，支持链式调用
     *
     * @example
     * hxzxUtils.date().endOf('day').format('YYYY-MM-DD HH:mm:ss'); // "xxxx-xx-xx 23:59:59"
     *
     * @example
     * // 还可以判断时间是否相等 hxzxUtils.date().startOf同理
     * hxzxUtils.date('2026-01-01 44:44:44').endOf('day').valueOf() === hxzxUtils.date('2026-01-01 44:44:44').endOf('day').valueOf(); // 表示是否同一天
     * hxzxUtils.date('2026-01-01 44:44:44').endOf('year').valueOf() === hxzxUtils.date('2026-01-01 44:44:44').endOf('year').valueOf(); // 表示是否同一年
     */
    endOf(type: HxzxUtilsDateOperationTypeAll): HxzxUtilsDateReturn;
    /**
     * 判断当前年份是否是闰年
     *
     * @returns true=闰年，false=平年
     */
    isLeapYear(): boolean;
};
/**
 * hxzx-utils 工具函数库
 */
declare const hxzxUtils: {
    /**
     * 工具库名称
     */
    name: string;
    /**
     * 工具库版本
     */
    version: string;
    /**
     * 数据类型工具
     * 提供数据类型判断和检测功能
     */
    type: {
        /**
         * 获取数据类型
         * 基于 `Object.prototype.toString` 机制判断，可准确识别容易被 `typeof` 误判的类型
         *
         * @param v - 任意数据
         * @returns 返回数据类型字符串
         *
         * @example
         * hxzxUtils.type.get("hello") // "string"
         *
         * @example
         * hxzxUtils.type.get([1, 2, 3]) // "array"
         *
         * @example
         * hxzxUtils.type.get(null) // "null"
         */
        get(v?: any): "" | "string" | "number" | "bigint" | "array" | "object" | "symbol" | "function" | "date" | "boolean" | "null" | "undefined" | "nan" | "map" | "set" | "promise" | "regexp";
        /**
         * 判断数据是否为 String 类型
         *
         * @param v - 待检测数据
         * @returns 如果是字符串返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isString("hello"); // true
         *
         * @example
         * hxzxUtils.type.isString(123); // false
         */
        isString(v?: any): boolean;
        /**
         * 判断数据是否为 Number 类型 (不包含 NaN)
         *
         * @param v - 待检测数据
         * @returns 如果是数字且非 NaN 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isNumber(123); // true
         *
         * @example
         * hxzxUtils.type.isNumber(NaN); // false
         */
        isNumber(v?: any): boolean;
        /**
         * 判断数据是否为 BigInt 类型
         *
         * @param v - 待检测数据
         * @returns 如果是 BigInt 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isBigint(BigInt(1)); // true
         *
         * @example
         * hxzxUtils.type.isBigint(1); // false
         */
        isBigint(v?: any): boolean;
        /**
         * 判断数据是否为 Array 类型
         *
         * @param v - 待检测数据
         * @returns 如果是数组返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isArray([1, 2]); // true
         *
         * @example
         * hxzxUtils.type.isArray({}); // false
         */
        isArray(v?: any): boolean;
        /**
         * 判断数据是否为 Object 类型
         *
         * @param v - 待检测数据
         * @returns 如果是纯对象返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isObject({}); // true
         *
         * @example
         * hxzxUtils.type.isObject([]); // false
         */
        isObject(v?: any): boolean;
        /**
         * 判断数据是否为 Symbol 类型
         *
         * @param v - 待检测数据
         * @returns 如果是 Symbol 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isSymbol(Symbol("a")); // true
         *
         * @example
         * hxzxUtils.type.isSymbol("a"); // false
         */
        isSymbol(v?: any): boolean;
        /**
         * 判断数据是否为 Function 类型
         *
         * @param v - 待检测数据
         * @returns 如果是函数返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isFunction(function(){}); // true
         *
         * @example
         * hxzxUtils.type.isFunction({}); // false
         */
        isFunction(v?: any): boolean;
        /**
         * 判断数据是否为 Date 类型
         *
         * @param v - 待检测数据
         * @returns 如果是日期对象返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isDate(new Date()); // true
         *
         * @example
         * hxzxUtils.type.isDate("2022-12-12"); // false
         */
        isDate(v?: any): boolean;
        /**
         * 判断数据是否为 Boolean 类型
         *
         * @param v - 待检测数据
         * @returns 如果是布尔值返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isBoolean(false); // true
         *
         * @example
         * hxzxUtils.type.isBoolean(0); // false
         */
        isBoolean(v?: any): boolean;
        /**
         * 判断数据是否为 null
         *
         * @param v - 待检测数据
         * @returns 如果是 null 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isNull(null); // true
         *
         * @example
         * hxzxUtils.type.isNull(undefined); // false
         */
        isNull(v?: any): boolean;
        /**
         * 判断数据是否为 undefined
         *
         * @param v - 待检测数据
         * @returns 如果是 undefined 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isUndefined(undefined); // true
         *
         * @example
         * hxzxUtils.type.isUndefined(null); // false
         */
        isUndefined(v?: any): boolean;
        /**
         * 判断数据是否为 NaN
         *
         * @param v - 待检测数据
         * @returns 如果是 NaN 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isNaN(NaN); // true
         *
         * @example
         * hxzxUtils.type.isNaN(1); // false
         */
        isNan(v?: any): boolean;
        /**
         * 判断数据是否为 Map 类型
         *
         * @param v - 待检测数据
         * @returns 如果是 Map 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isMap(new Map()); // true
         *
         * @example
         * hxzxUtils.type.isMap({}); // false
         */
        isMap(v?: any): boolean;
        /**
         * 判断数据是否为 Set 类型
         *
         * @param v - 待检测数据
         * @returns 如果是 Set 返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isSet(new Set()); // true
         *
         * @example
         * hxzxUtils.type.isSet([]); // false
         */
        isSet(v?: any): boolean;
        /**
         * 判断数据是否为 Promise 类型
         *
         * @param v - 待检测数据
         * @returns 如果是 Promise 对象返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isPromise(new Promise(function(ok){ok()})); // true
         *
         * @example
         * hxzxUtils.type.isPromise({then() {}}); // false
         */
        isPromise(v?: any): boolean;
        /**
         * 判断数据是否为 RegExp (正则表达式) 类型
         *
         * @param v - 待检测数据
         * @returns 如果是正则对象返回 true，否则返回 false
         *
         * @example
         * hxzxUtils.type.isRegexp(new RegExp()); // true
         *
         * @example
         * hxzxUtils.type.isRegexp('/test/'); // false
         */
        isRegexp(v?: any): boolean;
    };
    /**
     * 创建时间处理对象
     *
     * @param v - 初始值。可以是字符串、数字、Date 对象或任意可解析为时间的值，若不传或无法解析，则默认为当前时间
     * @returns 返回 HxzxUtilsDateReturn 时间工具对象，支持链式调用
     *
     * @example
     * hxzxUtils.date(); // 创建当前时间的处理对象
     *
     * @example
     * hxzxUtils.date('2023-01-01'); // 创建指定日期的处理对象
     */
    date(v?: any): HxzxUtilsDateReturn;
    /**
     * 函数防抖
     *
     * 触发高频事件后 n 秒内函数只会执行一次，如果 n 秒内高频事件再次被触发，则重新计算时间
     *
     * @param f - 需要防抖处理的回调函数
     * @param delay - 等待延迟时间（毫秒），默认 200ms
     * @param immediate - 是否立即执行
     *                    - true: 第一次触发时立即执行，随后在 delay 时间内再次触发无效
     *                    - false: 只有在停止触发 delay 时间后才执行（默认行为）
     * @returns 返回一个新的防抖函数，该函数不再返回原函数的返回值（因为通常是异步或定时执行）
     *
     * @example
     * // 基础用法：停止输入 500ms 后执行搜索
     * const search = hxzxUtils.debounce(function(query) { console.log('Searching:', query); }, 500);
     * input.addEventListener('input', function(e) { search(e.target.value) });
     *
     * @example
     * // 立即执行：点击按钮立即提交，防止 1 秒内重复点击
     * const submit = hxzxUtils.debounce(function() { console.log('Submitted'); }, 1000, true);
     * button.addEventListener('click', submit);
     */
    debounce<T extends (...args: any[]) => any>(f: T, delay?: number, immediate?: boolean): (...args: Parameters<T>) => void;
    /**
     * 函数节流
     *
     * 高频事件触发，但在 n 秒内只会执行一次，所以节流会稀释函数的执行频率
     *
     * 执行策略由 `immediate` 参数决定：
     * - true (默认): 立即执行模式。触发时立即执行第一次，随后在 `delay` 时间内忽略后续调用，直到时间结束
     * - false: 延迟执行模式。触发后等待 `delay` 时间，若期间没有新的触发则执行，否则重新计时（类似防抖，但保证至少执行一次间隔后的任务）
     *
     * @param f - 需要节流处理的原始函数
     * @param delay - 时间间隔，单位为毫秒 (ms)，默认为 200ms
     * @param immediate - 是否立即执行首次调用
     *                    - true: 触发即执行，随后进入冷却期
     *                    - false: 触发后进入等待期，冷却结束后执行
     * @returns 经过节流处理的新函数。该函数会保留原函数的 `this` 上下文和参数
     *
     * @example
     * // 场景：监听窗口滚动，每 200ms 最多执行一次
     * const handleScroll = hxzxUtils.throttle(function() {
     *   console.log('Scrolling...');
     * }, 200, true);
     * window.addEventListener('scroll', handleScroll);
     *
     * @example
     * // 场景：按钮点击，防止重复提交，点击后立即执行，1秒内再次点击无效
     * const submitBtn = hxzxUtils.throttle(function() {
     *   api.submit();
     * }, 1000, true);
     */
    throttle<T extends (...args: any[]) => any>(f: T, delay?: number, immediate?: boolean): (...args: Parameters<T>) => void;
    /**
     * 发布订阅事件通信
     * 提供事件的注册、触发、取消和数量查询功能
     *
     * @example
     * // 监听事件
     * hxzxUtils.eventBus.on('test', function(...arg) { console.log('收到1', ...arg) });
     * hxzxUtils.eventBus.on('test', function(...arg) { console.log('收到2', ...arg) });
     *
     * // 触发事件
     * hxzxUtils.eventBus.emit('test', '参数1', '参数2');
     *
     * // 获取事件订阅数量
     * hxzxUtils.eventBus.getSize('test');
     *
     * // 判断事件是否被订阅
     * hxzxUtils.eventBus.hasOn('test');
     *
     * // 取消监听
     * hxzxUtils.eventBus.off('test');
     */
    eventBus: {
        /**
         * 触发事件（发布）
         * 执行指定 ID 下所有已注册的回调函数，并传递参数
         *
         * @param id - 事件唯一标识 ID
         * @param parameter - 传递给回调函数的参数列表
         */
        emit(id: string, ...parameter: any[]): void;
        /**
         * 监听事件（订阅）
         * 将回调函数注册到指定 ID 的事件列表中
         *
         * @param id - 事件唯一标识 ID
         * @param f - 需要执行的回调函数
         */
        on(id: string, f: HxzxUtilsEventBusFunction): void;
        /**
         * 检测指定 ID 是否被订阅
         *
         * @param id - 事件唯一标识 ID
         * @returns 如果事件被订阅返回 true，否则返回 false
         */
        hasOn(id: string): boolean;
        /**
         * 取消监听（退订）
         * 支持三种移除模式：
         * 1. **清空所有**：不传任何参数 (`off()`) -> 清除所有事件监听
         * 2. **移除某类**：只传 ID (`off('id')`) -> 移除该 ID 下的所有回调
         * 3. **移除单个**：传 ID 和函数 (`off('id', fn)`) -> 仅移除该 ID 下匹配的特定回调
         *
         * @param id - (可选) 事件唯一标识 ID。若不传，则清空所有事件
         * @param f - (可选) 需要移除的特定回调函数。若只传 ID，则移除该 ID 下所有函数
         */
        off(id?: string, f?: HxzxUtilsEventBusFunction): void;
        /**
         * 获取订阅数量
         * 支持两种查询模式：
         * 1. **查询总数**：不传参数 (`getSize()`) -> 返回所有事件 ID 的总数量
         * 2. **查询单项**：传 ID (`getSize('id')`) -> 返回该 ID 下注册的回调函数数量
         *
         * @param id - (可选) 事件唯一标识 ID。若不传，返回全局事件总数
         * @returns 事件总数或指定事件下的回调函数数量
         */
        getSize(id?: string): number;
    };
    /**
     * 消息队列
     * 提供任务的串行执行、队列管理功能
     *
     * @example
     * // 初始化队列
     * const queue = hxzxUtils.queue();
     *
     * // 添加任务
     * queue.push(function(done) {
     *   // 异步操作
     *   setTimeout(function() {
     *     console.log('任务1完成');
     *     done(); // 必须调用 done() 才能执行下一个任务
     *   }, 1000);
     * });
     *
     * // 添加另一个任务
     * queue.push(function(done) {
     *   // 异步操作
     *   setTimeout(funcion() {
     *     console.log('任务2完成');
     *     done(); // 必须调用 done() 才能执行下一个任务
     *   }, 500);
     * });
     */
    queue(): {
        /**
         * 向队列中添加新任务
         * 任务将按加入顺序串行执行。添加后会自动尝试触发执行流程，如果当前没有任务正在运行，新任务会立即开始；否则将排队等待
         *
         * @param f - 任务回调函数，该函数接收一个 `done` 参数，必须在异步操作完成后调用 `done()`，以通知队列执行下一个任务。若未调用，队列将阻塞
         */
        push(f: HxzxUtilsQueueCallbackFunction): void;
        /**
         * 获取当前队列中的任务数量
         * 包含正在执行的任务（如果有）和等待执行的任务
         *
         * @returns 队列长度
         */
        getSize(): number;
        /**
         * 清空队列
         * 移除所有等待执行的任务，并重置执行状态
         * 注意：如果当前有任务正在执行，该任务会继续完成，但后续任务将被取消
         */
        clear(): void;
    };
    /**
     * 随机数据工具
     * 提供各种随机数据生成功能
     */
    random: {
        /**
         * 生成指定范围内的随机数
         *
         * 支持整数和小数，均为闭区间 [min, max]（包含 min 和 max），若传入的 min > max，会自动交换两者顺序
         *
         * @param min - 最小值
         * @param max - 最大值
         * @param decimalPlaces - 保留小数位数，默认为 0（即生成整数）。若大于 0，则生成对应精度的小数
         * @returns 生成的随机数
         *
         * @example
         * hxzxUtils.random.number(1, 10);       // 可能返回 1 到 10 之间的任意整数
         * hxzxUtils.random.number(1.5, 5.5, 1); // 可能返回 1.5, 2.3, 5.5 等保留一位小数的数
         * hxzxUtils.random.number(10, 1);       // 自动处理为 1 到 10 的范围
         */
        number(min: number, max: number, decimalPlaces?: number): number;
        /**
         * 生成随机唯一标识符
         *
         * @returns 生成的唯一 ID 字符串
         *
         * @example
         * hxzxUtils.random.id(); // "550e8400-e29b-41d4-a716-446655440000" (示例)
         */
        id(): string;
        /**
         * 生成随机英文字母字符串
         *
         * @param count - 生成的字母数量，默认为 5
         * @param type - 字母大小写模式，默认为 "smallLetter"
         *   - "smallLetter": 全部小写 (a-z)
         *   - "capitalization": 全部大写 (A-Z)
         *   - "mix": 随机混合大小写
         * @returns 随机字母字符串
         *
         * @example
         * hxzxUtils.random.english(3, "smallLetter");    // "abc"
         * hxzxUtils.random.english(3, "capitalization"); // "XYZ"
         * hxzxUtils.random.english(3, "mix");            // "aBc"
         */
        english(count?: number, type?: "smallLetter" | "capitalization" | "mix"): string;
        /**
         * 生成随机中文字符串
         *
         * 基于 Unicode 编码范围 [\u4e00-\u9fa5] (19968-40869) 生成常用汉字
         *
         * @param count - 生成的汉字数量，默认为 5
         * @returns 生成的中文汉字字符串
         *
         * @example
         * hxzxUtils.random.chinese(3); // "櫽生絔" (示例)
         */
        chinese(count?: number): string;
        /**
         * 生成随机颜色
         * @param _.format 格式 hex/rgb/rgba 默认hex
         * @param _.transparent 透明度，仅 format=rgba 生效，默认1不透明，范围0-1
         *
         * @example
         *
         * hxzxUtils.random.color(); // "#000000" (示例)
         * hxzxUtils.random.color({format: 'rgb'}); // "rgb(0, 0, 0)" (示例)
         * hxzxUtils.random.color({format: 'rgba', transparent: 0.1}); // "rgba(0, 0, 0, 0.1)" (示例)
         * // 如何颜色透明度随机
         * hxzxUtils.random.color({format: 'rgba', transparent: hxzxUtils.random.number(0, 1, 2)}); // "rgba(0, 0, 0, 0.1)" (示例)
         */
        color(_?: {
            format: "hex" | "rgb" | "rgba";
            transparent?: number;
        }): string;
    };
    /**
     * 字母索引互转工具
     * 提供数字索引与字母字符串之间的相互转换功能
     */
    cial: {
        /**
         * 将数字索引转换为字母字符串（类似 Excel 列名生成规则）
         *
         * 转换逻辑：
         * - 1 -> A, 2 -> B, ..., 26 -> Z
         * - 27 -> AA, 28 -> AB, ..., 52 -> AZ
         * - 支持大写和小写两种模式
         *
         * @param index - 数字索引，从1开始
         * @param sensitive - 大小写模式："up" (大写，默认) 或 "down" (小写)
         * @returns 转换后的字母字符串
         *
         * @example
         * hxzxUtils.cial.itl(1);      // "A"
         * hxzxUtils.cial.itl(26);     // "Z"
         * hxzxUtils.cial.itl(27);     // "AA"
         * hxzxUtils.cial.itl(1, "down"); // "a"
         * hxzxUtils.cial.itl(27, "down"); // "aa"
         */
        itl(index: number, sensitive?: "up" | "down"): string;
        /**
         * 将字母字符串转换为数字索引（`itl` 的逆运算）
         *
         * 转换逻辑（类似 Excel 列名解析）：
         * - "A" -> 1
         * - "Z" -> 26
         * - "AA" -> 27
         * - "AB" -> 28
         *
         * 注意：
         * - 输入不区分大小写，内部会自动转换为大写处理
         * - 返回值为 1-based 索引（即 A 对应 1）
         *
         * @param index - 字母字符串（支持单字符或多字符，如 "A", "Z", "AA"）
         * @returns 对应的数字索引
         *
         * @example
         * hxzxUtils.cial.lti("A");   // 1
         * hxzxUtils.cial.lti("Z");   // 26
         * hxzxUtils.cial.lti("AA");  // 27
         * hxzxUtils.cial.lti("ab");  // 27 (自动转为大写处理)
         */
        lti(index: string): number;
    };
    /**
     * 存储单位换算工具
     * 提供不同存储单位之间的转换功能
     *
     * @param value - 存储值
     * @param unit - 存储单位，默认为 "B"
     * @returns 存储单位换算对象，包含 convert 和 auto 方法
     *
     * @example
     * // 转换指定单位
     * console.log(hxzxUtils.storageConversion(1024, 'KB').convert('MB', 2)); // 1.00
     *
     * // 自动转换到合适单位
     * console.log(hxzxUtils.storageConversion(1024 * 1024, 'B').auto(2)); // 1.00MB
     */
    storageConversion(value: number, unit?: HxzxUtilsStorageUnit): {
        /**
         * 转换到指定存储单位
         *
         * @param unit - 转换后的单位
         * @param decimalCount - 保留几位小数，默认 0
         * @returns 转换后的值
         */
        convert(unit: HxzxUtilsStorageUnit, decimalCount?: number): number;
        /**
         * 自动转换到合适的存储单位
         *
         * @param decimalCount - 保留几位小数，默认 0
         * @returns 转换后的值，包含存储单位
         */
        auto(decimalCount?: number): string;
    };
    /**
     * 异步等待指定时长
     *
     * 返回一个 Promise，在指定的毫秒数后 resolve
     * 常用于在 async/await 流程中制造延迟
     *
     * 特殊行为：
     * - 如果 timeout 未传、为 0、负数或非数字类型，Promise 会立即 resolve (相当于宏任务延迟)，不会阻塞主线程
     *
     * @param timeout - 等待时长，单位为毫秒 (ms)，默认为 0
     * @returns 等待指定时间后的 Promise
     *
     * @example
     * await hxzxUtils.wait(1000); // 等待 1 秒
     *
     * @example
     * await hxzxUtils.wait(2000); // 等待 2 秒
     */
    wait(timeout?: number): Promise<void>;
    /**
     * 数据加解密工具
     * 提供数据加密和解密功能
     *
     * @returns 加密解密工具对象，包含 encrypt 和 decrypt 方法
     *
     * @example
     * // 加密数据
     * const res = hxzxUtils.encryption().encrypt({ secret: "hello" }, "my-password");
     * console.log(res.text); // 加密后的 Base64 字符串
     * console.log(res.password); // "my-password"
     *
     * // 解密数据
     * const data = hxzxUtils.encryption().decrypt(res.text, "my-password");
     * if (data) {
     *   console.log(data.secret); // "hello"
     * }
     */
    encryption(): {
        /**
         * 数据加密
         *
         * 加密流程：
         * 1. 生成随机 ID 和时间戳，构建包含元数据的 JSON 对象
         * 2. 若未提供密码，自动生成一个 10 位随机英文密码
         * 3. 将 JSON 字符串和密码分别转为 UTF-8 字节流
         * 4. 使用 XOR（异或）算法，用密码字节流循环加密数据字节流
         * 5. 将加密后的字节流转为 Base64 字符串
         *
         * ⚠️ 安全提示：此算法适用于前端数据混淆、防篡改或轻量级隐私保护，
         * 不适用于高安全级别的敏感数据传输（如银行卡号），建议使用 AES/RSA
         *
         * @param value - 需要加密的内容（任意可序列化的 JS 对象）
         * @param password - 可选密码。若不传，将自动生成随机密码并返回，请务必保存返回的 password，一旦丢失，由于是随机生成的，数据将永久无法解密
         * @returns 包含加密文本 (`text`) 和密码 (`password`) 的对象
         */
        encrypt(value: any, password?: string): {
            text: string;
            password: string;
        };
        /**
         * 数据解密
         *
         * 解密流程：
         * 1. 将 Base64 字符串还原为加密的字节流
         * 2. 使用相同的密码进行 XOR 逆运算，还原原始 JSON 字节流
         * 3. 解析 JSON，验证密码、ID 和时间戳是否匹配（防止篡改或密码错误）
         * 4. 提取原始数据
         *
         * @param value - 需要解密的 Base64 字符串（来自 encrypt 返回的 text）
         * @param password - 解密所需的密码
         * @returns 解密后的原始数据；若密码错误或数据损坏，返回 null
         */
        decrypt<T = any>(value: string, password: string): T | null;
    };
    /**
     * 字符串工具
     * 提供字符串处理和操作功能
     */
    string: {
        /**
         * 将字符串截断至指定长度并添加省略号
         *
         * 规则：
         * - 如果字符串长度超过指定 length，则截取前 length 个字符并追加 "..."
         * - 如果字符串长度未超过 length，或 length 无效（<=0），则返回原字符串
         *
         * @param value - 需要处理的原始字符串
         * @param length - 截断阈值长度
         *                 - 若 <= 0 或非数字，视为无效，直接返回原字符串
         *                 - 若 > 0，作为最大显示字符数（不包含省略号）
         * @returns 处理后的字符串（可能包含 "..."）
         *
         * @example
         * hxzxUtils.string.ellipsis("Hello World", 5);  // "Hello..."
         * hxzxUtils.string.ellipsis("Hi", 5);           // "Hi"
         * hxzxUtils.string.ellipsis("Test", 0);         // "Test" (长度无效，不截断)
         * hxzxUtils.string.ellipsis("", 5);             // ""
         */
        ellipsis(value: string, length: number): string;
        /**
         * 关键字高亮
         *
         * @param value - 原始字符串
         * @param keyword - 关键字
         * @param color - 高亮颜色，默认 #f56c6c
         * @returns 处理后的 html 字符串
         *
         * @example
         * hxzxUtils.string.keywordHighlighting("Hello World", "world"); // 输出: Hello <span style="color:#f56c6c">World</span>
         */
        keywordHighlighting(value: string, keyword: string, color?: string): string;
    };
    /**
     * 数字工具
     * 提供字符串处理和操作功能
     */
    number: {
        /**
         * 数字转成友好文本
         * @param value
         * @example
         * hxzxUtils.number.friendly(); // 输出: 0
         * hxzxUtils.number.friendly(''); // 输出: 0
         * hxzxUtils.number.friendly([]); // 输出: 0
         * hxzxUtils.number.friendly(1231); // 输出: 1231
         * hxzxUtils.number.friendly(10000); // 输出: 1万
         * hxzxUtils.number.friendly(10500); // 输出: 1万
         * hxzxUtils.number.friendly(11000); // 输出: 1.1万
         * hxzxUtils.number.friendly(100000); // 输出: 10万
         * hxzxUtils.number.friendly(10000000); // 输出: 1000万
         * hxzxUtils.number.friendly(110000000); // 输出: 1.1亿
         */
        friendly(value: any): string;
    };
    /**
     * 数组工具
     * 提供数组处理和操作功能
     */
    array: {
        /**
         * 根据数组项上的属性值分组
         *
         * @param list - 要处理的原始数组
         * @param k - 属性
         * @returns 分好组的对象数组
         *
         * @example
         * const data = [
         *   { name: "Alice", age: 25 },
         *   { name: "Bob", age: 30 },
         *   { name: "Charlie", age: 25 },
         *   { name: "David", age: 30 },
         * ];
         * const obj = hxzxUtils.array.groupByIV(data, "age");
         * console.log(obj);
         * // obj = {
         * //     "25": [
         * //         {
         * //             "name": "Alice",
         * //             "age": 25
         * //         },
         * //         {
         * //             "name": "Charlie",
         * //             "age": 25
         * //         }
         * //     ],
         * //     "30": [
         * //         {
         * //             "name": "Bob",
         * //             "age": 30
         * //         },
         * //         {
         * //             "name": "David",
         * //             "age": 30
         * //         }
         * //     ]
         * // }
         */
        groupByIV<A extends Record<string, any>, K extends keyof A>(list: A[], k: K): Record<PropertyKey, A[]>;
        /**
         * 数组根据长度分组
         *
         * @param list - 要分组的数组
         * @param size - 每组的长度，默认为 1
         * @returns 组合的二维数组
         *
         * @example
         * // 1. 正常分块
         * const data = [1, 2, 3, 4, 5, 6, 7];
         * console.log(hxzxUtils.array.groupByBL(data, 3));
         * // 输出: [ [1, 2, 3], [4, 5, 6], [7] ]
         * // 注意：最后一块不足 3 个，保留剩余元素
         *
         * // 2. 大小为 1
         * console.log(hxzxUtils.array.groupByBL(["a", "b"], 1));
         * // 输出: [ ['a'], ['b'] ]
         *
         * // 3. 大小超过数组长度
         * console.log(hxzxUtils.array.groupByBL([1, 2], 5));
         * // 输出: [ [1, 2] ] (只有一块)
         *
         * // 4. 无效大小 (<=0)
         * console.log(hxzxUtils.array.groupByBL([1, 2], 0));
         * // 输出: [] (空数组)
         */
        groupByBL<T = any>(list: T[], size?: number): T[][];
    };
    /**
     * 对象工具
     * 提供对象处理和操作功能
     */
    object: {
        /**
         * 获取对象的值（支持深度路径，如 'user.info.name'）
         *
         * @param obj - 源对象
         * @param key - 属性路径，支持点号分隔 (例如: 'a.b.c') 或 单个属性名
         * @param defaultValue - 没取到时的默认值，默认 undefined
         * @returns 获取到的值，类型为 T
         *
         * @example
         * // 简单属性
         * hxzxUtils.object.getValueByKey({ name: 'Tom' }, 'name');
         * // 输出: 'Tom'
         *
         * // 深度属性
         * const data = { user: { info: { age: 18 } } };
         * hxzxUtils.object.getValueByKey(data, 'user.info.age');
         * // 输出: 18
         *
         * // 属性不存在，返回默认值
         * hxzxUtils.object.getValueByKey(data, 'user.info.gender', 'unknown');
         * // 输出: 'unknown'
         *
         * // 结果为 null/undefined，返回默认值
         * hxzxUtils.object.getValueByKey({ user: null }, 'user.info.age', 0);
         * // 输出: 0
         *
         * // 数组
         * const testArray = { a: [{ b: 1 }] };
         * hxzxUtils.object.getValueByKey(testArray, "a.0.b");
         * // 输出：1
         *
         * // 对象属性包含`.`关键字时
         * const complexData1 = { "company.cccc": { department: { team: { leader: { name: "张三" } } } } };
         * hxzxUtils.object.getValueByKey(complexData1, ["company.cccc", "department", "team", "leader", "name"]);
         * // 输出：张三
         *
         * // 对象属性包含`Symbol`时
         * const s = Symbol("test");
         * const a = { b: 1, [s]: 2 };
         * hxzxUtils.object.getValueByKey(a, [s]);
         * // 输出：2
         */
        getValueByKey<T = undefined>(obj: any, key: string | PropertyKey[], defaultValue?: T): T;
        /**
         * 判断对象是否为空
         * @param obj - 源对象
         * @returns true为空，false不为空
         * @example
         *
         * hxzxUtils.object.isEmpty({}); // true
         *
         * hxzxUtils.object.isEmpty({a:1}); // false
         */
        isEmpty(obj: any): boolean;
    };
    /**
     * 数据格式校验
     */
    verification: {
        /**
         * 校验内容是否为非空字符串，并可指定长度范围
         *
         * 校验规则：
         * 1. 必须是字符串类型。
         * 2. 长度必须在 [min, max] 范围内（闭区间）。
         * 3. 默认最小长度 min 为 1（即不允许为空字符串 ""）。
         * 4. 若传入的 min < 1，会自动修正为 1。
         * 5. 若未传入 max 或 max 无效，则只校验最小长度，不校验最大长度。
         *
         * @param value - 需要校验的内容
         * @param options - 校验配置项
         * @param options.min - 最小长度限制。
         *                      - 默认为 1。
         *                      - 若传入值小于 1，内部会自动按 1 处理。
         * @param options.max - 最大长度限制。
         *                      - 可选，若不传则不限制最大长度。
         *                      - 若传入，需保证 max >= min 才生效（根据当前逻辑，若 max <= min 则跳过最大长度检查）。
         * @returns {boolean}
         *          - true: 校验通过（是字符串且长度符合要求）。
         *          - false: 校验失败（非字符串、空字符串、或长度超出范围）。
         *
         * @example
         * hxzxUtils.verification.string("hello");                 // true (默认 min=1)
         * hxzxUtils.verification.string("");                      // false (空字符串)
         * hxzxUtils.verification.string("hi", { min: 3 });        // false (长度 2 < 3)
         * hxzxUtils.verification.string("hello", { min: 2, max: 4 }); // false (长度 5 > 4)
         * hxzxUtils.verification.string("ok", { min: 0 });        // true (min<1 被修正为 1, "ok" 长度 2 >= 1)
         */
        string(value: any, options?: {
            min?: number;
            max?: number;
        }): boolean;
        /**
         * 校验内容是否为手机号
         *
         * 规则：/^1[3-9]\d{9}$/
         *
         * @param value - 需要校验的内容
         * @returns {boolean}
         *          - true: 校验通过
         *          - false: 校验失败
         * @example
         * hxzxUtils.verification.phone('13800138000'); // true
         * hxzxUtils.verification.phone('12345678901'); // false (第二位不能是2)
         * hxzxUtils.verification.phone(13912345678);   // true
         * hxzxUtils.verification.phone(null);          // false
         */
        phone(value: any): boolean;
    };
};
export default hxzxUtils;