@ivu-plus/i-utils/dist/index.d.ts

前端模块化 JavaScript 工具库

declare namespace SORT {
    let DESC: number;
    let ASC: number;
    let RANDOM: number;
}

declare namespace MATH {
    let ROUND: number;
    let ROUND_FLOOR: number;
}

declare namespace LANG {
    let ZH: string;
    let EN: string;
}

declare namespace REGEXP {
    let CH: RegExp;
    let EN: RegExp;
    let LOWER_CASE: RegExp;
    let UPPER_CASE: RegExp;
    let CH_NAME: RegExp;
    let EN_NAME: RegExp;
    let NUMBER: RegExp;
    let INTEGER: RegExp;
    let DECIMAL: RegExp;
    let INT_OR_FLOAT: RegExp;
    let MOBILE: RegExp;
    let PHONE: RegExp;
    let EMAIL: RegExp;
    let ID_CARD: RegExp;
    let ID_CARD15: RegExp;
    let ID_CARD18: RegExp;
    let BANK_CARD: RegExp;
    let POST_CODE: RegExp;
    let URL: RegExp;
    let IP: RegExp;
    let IP6: RegExp;
    let EXTERNAL: RegExp;
}

declare namespace DATE {
    namespace AM_PM {
        namespace zh {
            let AM: string;
            let PM: string;
        }
        namespace en {
            let AM_1: string;
            export { AM_1 as AM };
            let PM_1: string;
            export { PM_1 as PM };
        }
    }
    namespace WEEK {
        export namespace zh_1 {
            let FULL: string[];
            let SHORT: string[];
            let MINI: string[];
        }
        export { zh_1 as zh };
        export namespace en_1 {
            let FULL_1: string[];
            export { FULL_1 as FULL };
            let SHORT_1: string[];
            export { SHORT_1 as SHORT };
            let MINI_1: string[];
            export { MINI_1 as MINI };
        }
        export { en_1 as en };
    }
    namespace MONTH {
        export namespace zh_2 {
            let FULL_2: string[];
            export { FULL_2 as FULL };
            let SHORT_2: string[];
            export { SHORT_2 as SHORT };
        }
        export { zh_2 as zh };
        export namespace en_2 {
            let FULL_3: string[];
            export { FULL_3 as FULL };
            let SHORT_3: string[];
            export { SHORT_3 as SHORT };
        }
        export { en_2 as en };
    }
    namespace QUARTER {
        export namespace zh_3 {
            let FULL_4: string[];
            export { FULL_4 as FULL };
            let SHORT_4: string[];
            export { SHORT_4 as SHORT };
            let MINI_2: string[];
            export { MINI_2 as MINI };
        }
        export { zh_3 as zh };
        export namespace en_3 {
            let FULL_5: string[];
            export { FULL_5 as FULL };
            let SHORT_5: string[];
            export { SHORT_5 as SHORT };
            let MINI_3: string[];
            export { MINI_3 as MINI };
        }
        export { en_3 as en };
    }
    namespace OVER_TIME {
        export namespace zh_4 {
            export let YEAR: string;
            let MONTH_1: string;
            export { MONTH_1 as MONTH };
            export let DATE: string;
            export let HOUR: string;
            export let MINUTE: string;
            export let SECOND: string;
            export let MILLISECOND: string;
            export let DAY: string;
            let QUARTER_1: string;
            export { QUARTER_1 as QUARTER };
        }
        export { zh_4 as zh };
        export namespace en_4 {
            let YEAR_1: string;
            export { YEAR_1 as YEAR };
            let MONTH_2: string;
            export { MONTH_2 as MONTH };
            let DATE_1: string;
            export { DATE_1 as DATE };
            let HOUR_1: string;
            export { HOUR_1 as HOUR };
            let MINUTE_1: string;
            export { MINUTE_1 as MINUTE };
            let SECOND_1: string;
            export { SECOND_1 as SECOND };
            let MILLISECOND_1: string;
            export { MILLISECOND_1 as MILLISECOND };
            let DAY_1: string;
            export { DAY_1 as DAY };
            let QUARTER_2: string;
            export { QUARTER_2 as QUARTER };
        }
        export { en_4 as en };
    }
    namespace PASS_TIME {
        export namespace zh_5 {
            let YEAR_2: string;
            export { YEAR_2 as YEAR };
            let MONTH_3: string;
            export { MONTH_3 as MONTH };
            let DAY_2: string;
            export { DAY_2 as DAY };
            export let BEFORE_YESTERDAY: string;
            export let YESTERDAY: string;
            export let TODAY: string;
            let HOUR_2: string;
            export { HOUR_2 as HOUR };
            let MINUTE_2: string;
            export { MINUTE_2 as MINUTE };
            export let JUST: string;
        }
        export { zh_5 as zh };
        export namespace en_5 {
            let YEAR_3: string;
            export { YEAR_3 as YEAR };
            let MONTH_4: string;
            export { MONTH_4 as MONTH };
            let DAY_3: string;
            export { DAY_3 as DAY };
            let BEFORE_YESTERDAY_1: string;
            export { BEFORE_YESTERDAY_1 as BEFORE_YESTERDAY };
            let YESTERDAY_1: string;
            export { YESTERDAY_1 as YESTERDAY };
            let TODAY_1: string;
            export { TODAY_1 as TODAY };
            let HOUR_3: string;
            export { HOUR_3 as HOUR };
            let MINUTE_3: string;
            export { MINUTE_3 as MINUTE };
            let JUST_1: string;
            export { JUST_1 as JUST };
        }
        export { en_5 as en };
    }
    namespace HOLIDAY {
        let zh_6: string[];
        export { zh_6 as zh };
        let en_6: string[];
        export { en_6 as en };
    }
    namespace ZODIAC {
        let zh_7: string[];
        export { zh_7 as zh };
        let en_7: string[];
        export { en_7 as en };
    }
    namespace CHINESE_ZODIAC {
        let zh_8: string[];
        export { zh_8 as zh };
        let en_8: string[];
        export { en_8 as en };
    }
    namespace HEAVENLY_STEMS {
        let zh_9: string[];
        export { zh_9 as zh };
        let en_9: string[];
        export { en_9 as en };
    }
    namespace EARTHLY_BRANCHES {
        let zh_10: string[];
        export { zh_10 as zh };
        let en_10: string[];
        export { en_10 as en };
    }
}

declare const KEYCODE: {
    8: string;
    9: string;
    13: string;
    16: string;
    17: string;
    18: string;
    19: string;
    20: string;
    27: string;
    32: string;
    33: string;
    34: string;
    35: string;
    36: string;
    37: string;
    38: string;
    39: string;
    40: string;
    42: string;
    45: string;
    46: string;
    48: string;
    49: string;
    50: string;
    51: string;
    52: string;
    53: string;
    54: string;
    55: string;
    56: string;
    57: string;
    65: string;
    66: string;
    67: string;
    68: string;
    69: string;
    70: string;
    71: string;
    72: string;
    73: string;
    74: string;
    75: string;
    76: string;
    77: string;
    78: string;
    79: string;
    80: string;
    81: string;
    82: string;
    83: string;
    84: string;
    85: string;
    86: string;
    87: string;
    88: string;
    89: string;
    90: string;
    91: string;
    93: string;
    96: string;
    97: string;
    98: string;
    99: string;
    100: string;
    101: string;
    102: string;
    103: string;
    104: string;
    105: string;
    106: string;
    107: string;
    109: string;
    110: string;
    111: string;
    112: string;
    113: string;
    114: string;
    115: string;
    116: string;
    117: string;
    118: string;
    119: string;
    120: string;
    121: string;
    122: string;
    123: string;
    144: string;
    145: string;
    182: string;
    183: string;
    186: string;
    187: string;
    188: string;
    189: string;
    190: string;
    191: string;
    192: string;
    219: string;
    220: string;
    221: string;
    222: string;
};

declare namespace ID_CARD {
    let PROVINCE: {
        11: string;
        12: string;
        13: string;
        14: string;
        15: string;
        21: string;
        22: string;
        23: string;
        31: string;
        32: string;
        33: string;
        34: string;
        35: string;
        36: string;
        37: string;
        41: string;
        42: string;
        43: string;
        44: string;
        45: string;
        46: string;
        50: string;
        51: string;
        52: string;
        53: string;
        54: string;
        61: string;
        62: string;
        63: string;
        64: string;
        65: string;
        71: string;
        81: string;
        82: string;
        91: string;
    };
    namespace SEX {
        let MAN: string;
        let WOMAN: string;
    }
}

/**
 * 字符串中是否包含指定的元素
 * @param {String} value 包含的元素
 * @param {String} str 查找的字符串
 * @returns {Boolean} 返回true和false
 */
declare function inString(value: string, str: string): boolean;
/**
 * 去除字符串前后位置空格
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function trim(value: string): string;
/**
 * 去除字符串开始位置的空格
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function trimStart(value: string): string;
/**
 * 去除字符串结束位置的空格
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function trimEnd(value: string): string;
/**
 * 去除字符串中全部的空格
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function trimAll(value: string): string;
/**
 * 替换所有指定字符串为新的字符串
 * @param {String} value 参数
 * @param {String} oldSubstr 需要替换的字符串
 * @param {String} newSubstr 替换后的字符串
 * @returns {String} 返回处理后的字符串
 */
declare function replaceAll(value: string, oldSubstr: string, newSubstr: string): string;
/**
 * 字符串转大写
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toUpperCase(value: string): string;
/**
 * 字符串转小写
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toLowerCase(value: string): string;
/**
 * 转为 snake_case 下划线命名
 * @description 支持 驼峰命名，短横命名，帕斯卡命名
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toSnakeCase(value: string): string;
/**
 * 转为 kebab-case 短横命名
 * @description 支持 下划线，驼峰命名，帕斯卡命名
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toKebabCase(value: string): string;
/**
 * 转为 camelCase 驼峰命名
 * @description 支持 下划线命名，短横命名，帕斯卡命名
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toCamelCase(value: string): string;
/**
 * 转为 PascalCase 帕斯卡命名
 * @description 支持 下划线命名，短横命名，驼峰命名
 * @param {String} value 参数
 * @returns {String} 返回处理后的字符串
 */
declare function toPascalCase(value: string): string;
/**
 * 数字前补齐0达到指定位数
 * @description 相当于原生的 padStart(2,'0')
 * @param {Number|String} value 补零的数字
 * @param {Number} maxLength 补齐0后的最大长度，默认2位
 * @returns {String} 返回补0后指定位数的字符串
 */
declare function zeroStart(value: number | string, maxLength?: number): string;
/**
 * 数字后补齐0达到指定位数
 * @description 相当于原生的 padEnd(2,'0')
 * @param {Number|String} value 补零的数字
 * @param {Number} maxLength 补齐0后的最大长度，默认2位
 * @returns {String} 返回补0后指定位数的字符串
 */
declare function zeroEnd(value: number | string, maxLength?: number): string;
/**
 * 格式化为标题样式
 * @param {String} value 字符串值
 * @returns {String} 返回格式化后的标题样式
 */
declare function formatTitle(value: string): string;
/**
 * 格式化字符串模版
 * @param {String} value 字符串值
 * @param {Object} data 模版数据
 * @returns {String} 返回格式化后的模版字符串
 */
declare function formatTemplate(value: string, data: Object): string;
/**
 * 格式化千分位数字
 * @description 支持任意数据传参，如果非数字则不会格式化，并返回原数据
 * @param {Number|String} num 数字
 * @returns {String} 返回格式化后的千分位数字
 */
declare function formatThousand(num: number | string): string;
/**
 * 格式化人民币金额大写
 * @param {Number|String} money 金额
 * @returns {String} 返回金额大写
 */
declare function formatRmbChinese(money: number | string): string;

/**
 * 转为数字类型
 * @description 解决部分浏览器在转换 '08','09'等是0开头时被默认转8进制问题
 * @param {String,number} value 转换的值
 * @param {Number} radix 进制数，默认10进制
 * @returns {Number} 返回转换后的数字
 */
declare function parseInt(value: any, radix?: number): number;
/**
 * 转为小数类型
 * @param {String,number} value 转换的值
 * @returns {Number} 返回转换后的数字
 */
declare function parseFloat(value: any): number;

/**
 * 数组最小值
 * @param {Array} array 数组
 * @returns {Number} 返回最小值
 */
declare function arrayMin(array: any[]): number;
/**
 * 数组最大值
 * @param {Array} array 数组
 * @returns {Number} 返回最大值
 */
declare function arrayMax(array: any[]): number;
/**
 * 数组求和
 * @param {Array} array 数组
 * @returns {Number} 返回和
 */
declare function arraySum(array: any[]): number;
/**
 * 数组求平均值
 * @param {Array} array 数组
 * @returns {Number} 返回平均数
 */
declare function arrayAvg(array: any[]): number;
/**
 * 数组中是否包含指定的元素
 * @param {String|Number} value 元素
 * @param {Array} array 查找的数组
 * @returns {Boolean} 返回结果
 */
declare function inArray(value: string | number, array: any[]): boolean;
/**
 * 比较两个数组是否相等
 * @param {Array} array1 数组1
 * @param {Array} array2 数组2
 * @returns {Boolean} 返回结果
 */
declare function arrayEquals(array1: any[], array2: any[]): boolean;
/**
 * 生成指定长度的数组
 * @param {Number} length 长度，默认 0
 * @returns {Array} 返回数组
 */
declare function arrayCreate(length?: number): any[];
/**
 * 数组指定位置添加元素
 * @description 如果数组为空，则在0位置添加元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @param {*} value 添加的元素
 * @returns {Array} 返回操作后的数组
 */
declare function arrayInsert(array?: any[], index?: number, value?: any): any[];
/**
 * 数组指定位置前面添加元素
 * @description 如果数组为空，则在0位置添加元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @param {*} value 添加的元素
 * @returns {Array} 返回操作后的数组
 */
declare function arrayInsertBefore(array?: any[], index?: number, value?: any): any[];
/**
 * 数组指定位置后面添加元素
 * @description 如果数组为空，则在0位置添加元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @param {*} value 添加的元素
 * @returns {Array} 返回操作后的数组
 */
declare function arrayInsertAfter(array?: any[], index?: number, value?: any): any[];
/**
 * 数组指定位置删除元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayRemove(array?: any[], index?: number): any[];
/**
 * 数组指定位置前面删除元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayRemoveBefore(array?: any[], index?: number): any[];
/**
 * 数组指定位置后面删除元素
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayRemoveAfter(array?: any[], index?: number): any[];
/**
 * 数组置顶
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayTop(array?: any[], index?: number): any[];
/**
 * 数组置尾
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayBottom(array?: any[], index?: number): any[];
/**
 * 数组向上移动
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayUp(array?: any[], index?: number): any[];
/**
 * 数组向下移动
 * @param {Array} array 数组
 * @param {Number} index 下标位置，默认0
 * @returns {Array} 返回操作后的数组
 */
declare function arrayDown(array?: any[], index?: number): any[];
/**
 * 数组交换元素
 * @param {Array} array 数组
 * @param {Number} sourceIndex 原索引
 * @param {Number} targetIndex 目标索引
 * @returns {Array} 返回操作后的数组
 */
declare function arraySwap(array: any[], sourceIndex: number, targetIndex: number): any[];
/**
 * 数组排序
 * @param {Array} array 数组
 * @param {Number} mode 排序模式，参考常量集合中 数组常量，默认是升序
 * @returns {Array} 返回操作后的数组
 */
declare function arraySort(array: any[], mode?: number): any[];
/**
 * 数组属性混合排序
 * @description 排序默认为asc升序
 * @param {Array} array 数组
 * @param {Array} props 排序的属性
 * @returns {Array} 返回操作后的数组
 */
declare function arraySortBy(array: any[], props: any[]): any[];
/**
 * 数组元素去重
 * @param {Array} array 数组
 * @returns {Array} 返回操作后的数组
 */
declare function arrayUnique(array: any[]): any[];
/**
 * 数组打乱元素
 * @description 可以适用于一些抽奖人员列表打乱顺序
 * @param {Array} array 数组
 * @returns {Array} 返回操作后的数组
 */
declare function arrayShuffle(array: any[]): any[];
/**
 * 普通数组转树形结构
 * @description 包含id和pid属性关系的一维数组，转为children的树形结构
 * @param {Array} array 数组
 * @param {Object} setting 配置项
 * @returns {Array} 返回树形节点
 */
declare function arrayToTree(array: any[], setting?: Object): any[];
/**
 * 树形结构转普通数组
 * @param {Array} nodes 树形节点
 * @param {Object} setting 配置项
 * @returns {Array} 返回普通数组
 */
declare function treeToArray(nodes: any[], setting?: Object): any[];
/**
 * 数组求并集
 * @description 数组1 和 数组2 合并一起的元素集合
 * @param {Array} array1 数组1
 * @param {Array} array2 数组2
 * @returns {Array} 返回数组
 */
declare function arrayUnion(array1: any[], array2: any[]): any[];
/**
 * 数组求交集
 * @description 数组1 和 数组2 相同的元素集合
 * @param {Array} array1 数组1
 * @param {Array} array2 数组2
 * @returns {Array} 返回数组
 */
declare function arrayIntersect(array1: any[], array2: any[]): any[];
/**
 * 数组求差集
 * @description 数组1 中不包含 数组2 的元素集合
 * @param {Array} array1 数组1
 * @param {Array} array2 数组2
 * @returns {Array} 返回数组
 */
declare function arrayDifference(array1: any[], array2: any[]): any[];
/**
 * 数组求补集
 * @description 数组1 和 数组2 不相同的元素集合
 * @param {Array} array1 数组1
 * @param {Array} array2 数组2
 * @returns {Array} 返回数组
 */
declare function arrayComplement(array1: any[], array2: any[]): any[];

/**
 * map转object
 * @param {Map} map 参数
 * @returns {Object} 返回Object
 */
declare function mapToObject(map: Map<any, any>): Object;
/**
 * map转json字符串
 * @param {Map} map 参数
 * @returns {String} 返回Json字符串
 */
declare function mapToJson(map: Map<any, any>): string;
/**
 * object转map
 * @param {Object} obj 参数
 * @returns {Map} 返回Map
 */
declare function objectToMap(obj: Object): Map<any, any>;
/**
 * json字符串转map
 * @param {String} json json字符串
 * @returns {Map} 返回Map
 */
declare function jsonToMap(json: string): Map<any, any>;
/**
 * json对象转json字符串
 * @param {Object} json json对象
 * @returns {String} 返回Json字符串
 */
declare function stringifyJson(json: Object): string;
/**
 * json字符串转json对象
 * @param {String} json json字符串
 * @returns {Object} 返回Json对象
 */
declare function parseJson(json: string): Object;
/**
 * 浅拷贝数据
 * @param {*} source 拷贝的数据
 * @returns {*} 返回浅拷贝的数据
 */
declare function clone(source: any): any;
/**
 * 深拷贝数据
 * @param {*} source 拷贝的数据
 * @returns {*} 返回深拷贝的数据
 */
declare function deepClone(source: any): any;
/**
 * 比较两个对象是否相等
 * @description 方法只能对比简单的对象，不能包含function，另外对象的属性顺序不一致也是相等的
 * @param {Object} obj1 对象1
 * @param {Object} obj2 对象2
 * @returns {Boolean} 返回true和false
 */
declare function objectEquals(obj1: Object, obj2: Object): boolean;
/**
 * 合并对象
 * @param {Object} target 目标对象
 * @param {Object[]} source 原对象列表
 * @returns {Object} 返回合并后的对象
 */
declare function merge(target: Object, ...source: Object[]): Object;
/**
 * 根据字符串属性路径获取目标对象的值
 * @example
 * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
 * this._getValueByPath(res, 'data.pages.pageSize'); // 这里会输出20
 * @param {Object} target 目标对象
 * @param {String} path 字符串属性路径
 * @returns {Object} 返回目标对象
 */
declare function getValueByPath(target: Object, path?: string): Object;
/**
 * 根据字符串属性路径设置目标对象的值
 * @example
 * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
 * this._setValueByPath(res, 'data.pages.pageSize', 30); // 打印res对象会发现pageSize的值改为了30
 * @param {Object} target 目标对象
 * @param {String} path 字符串属性路径
 * @param {*} value 值
 */
declare function setValueByPath(target: Object, path: string, value: any): Object;

/**
 * 防抖函数
 * @description 事件执行后，在延迟时间内如果再次执行，会清空定时器重新延迟执行，举例：用户在输入框进行输入搜索，最终是会获取到最后一次输入，节约请求资源
 * @param {Function} fn 目标函数
 * @param {Number} delay 延迟时间，单位毫秒，默认 1*1000 毫秒
 * @param {Boolean} immediate 是否立即执行，默认true
 * @returns {Function} 返回function()
 */
declare function debounce(fn: Function, delay?: number, immediate?: boolean): Function;
/**
 * 节流函数
 * @description 高频触发时，在指定时间间隔内只执行一次，举例：监听页面滚动，不会频繁触发，只会在固定时间内获取一次
 * @param {Function} fn 目标函数
 * @param {Number} interval 时间间隔，单位毫秒，默认1*1000毫秒
 * @returns {Function} 返回function()
 */
declare function throttle(fn: Function, interval?: number): Function;
/**
 * 睡眠延迟执行
 * @description 需要配合 async/await 来达到延迟效果
 * @param {Number} delay 延迟时间，单位毫秒，默认1*1000毫秒
 */
declare function sleep(delay?: number): Promise<any>;

/**
 * 今天
 *@returns {String} 返回日期字符串
 */
declare function today(): string;
/**
 * 昨天
 * @returns {String} 返回日期字符串
 */
declare function yesterday(): string;
/**
 * 明天
 *@returns {String} 返回日期字符串
 */
declare function tomorrow(): string;
/**
 * 上周（7天前日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function lastWeek(date?: Date): string;
/**
 * 下周（7天后日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function nextWeek(date?: Date): string;
/**
 * 上个月（30天前日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function lastMonth(date?: Date): string;
/**
 * 下个月（30天后日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function nextMonth(date?: Date): string;
/**
 * 上一年（365天前日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function lastYear(date?: Date): string;
/**
 * 下一年（365天后日期）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function nextYear(date?: Date): string;
/**
 * 是否为上午
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isAM(date?: Date): boolean;
/**
 * 是否为下午
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isPM(date?: Date): boolean;
/**
 * 是否为今天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isToday(date?: Date): boolean;
/**
 * 是否为昨天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isYesterday(date?: Date): boolean;
/**
 * 是否为前天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isBeforeYesterday(date?: Date): boolean;
/**
 * 是否为明天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isTomorrow(date?: Date): boolean;
/**
 * 是否为后天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isAfterTomorrow(date?: Date): boolean;
/**
 * 是否为工作日
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isWorkday(date?: Date): boolean;
/**
 * 是否为周末（周六和周日）
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isWeekend(date?: Date): boolean;
/**
 * 是否为本周第一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isFirstDayOfWeek(date?: Date): boolean;
/**
 * 是否为本周最后一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isLastDayOfWeek(date?: Date): boolean;
/**
 * 是否为本月第一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isFirstDayOfMonth(date?: Date): boolean;
/**
 * 是否为本月最后一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isLastDayOfMonth(date?: Date): boolean;
/**
 * 是否为本年第一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isFirstDayOfYear(date?: Date): boolean;
/**
 * 是否为本年最后一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isLastDayOfYear(date?: Date): boolean;
/**
 * 是否为闰年
 * @description 闰年366天，平年365天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isLeapYear(date?: Date): boolean;
/**
 * 是否为平年
 * @description 闰年366天，平年365天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isCommonYear(date?: Date): boolean;
/**
 * 是否在日期之前
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isBefore(startDate: Date, endDate?: Date): boolean;
/**
 * 是否在日期之后
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期，默认当前日期
 * @returns {Boolean} 返回结果
 */
declare function isAfter(startDate: Date, endDate?: Date): boolean;
/**
 * 是否在两个日期之间
 * @param {Date} date 要比较的日期
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isBetween(date: Date, startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否为同一天
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSame(startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否为同一周
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSameWeek(startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否为同一个月
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSameMonth(startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否为同一年
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSameYear(startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否相同或之前
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSameOrBefore(startDate: Date, endDate: Date): boolean;
/**
 * 两个日期是否相同或之后
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Boolean} 返回结果
 */
declare function isSameOrAfter(startDate: Date, endDate: Date): boolean;
/**
 * 获得此刻的日期
 * @returns {Date} 返回日期
 */
declare function getNow(): Date;
/**
 * 获得当前日期字符串
 * @param {Date} date 日期参数，默认当前日期
 * @param {String} format 日期字符串格式
 * @returns {String} 返回日期字符串
 */
declare function getDate(date?: Date, format?: string): string;
/**
 * 获得当前日期时间字符串
 * @param {Date} date 日期参数，默认当前日期
 * @param {String} format 日期时间字符串格式
 * @returns {String} 返回日期时间字符串
 */
declare function getDateTime(date?: Date, format?: string): string;
/**
 * 获取当前时间戳
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回时间戳
 */
declare function getTimestamp(date?: Date): number;
/**
 * 获取当前Unix时间戳
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回Unix时间戳
 */
declare function getUnixTimestamp(date?: Date): number;
/**
 * 获得当前日期的对象形式
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Object} 返回日期的对象形式
 */
declare function getDateObject(date?: Date): Object;
/**
 * 获得当前日期的数组形式
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Object} 返回日期的数组形式
 */
declare function getDateArray(date?: Date): Object;
/**
 * 获得当前日期是周几
 * @param {Date} date 日期参数，默认当前日期
 * @param {String} format 周格式化结果：E：如“日”，EE：如“周日”, EEE：如“星期日”；默认为E，为空则返回数字
 * @param {String} lang 语言zh和en，默认zh
 * @returns {Number,String} 返回周几，会根据语言返回
 */
declare function getWeek(date?: Date, format?: string, lang?: string): number;
/**
 * 获得当前日期是第几季度
 * @param {Date} date 日期参数，默认当前日期
 * @param {String} format 季度格式化结果：Q：如“一”, QQ：如“一季度”；QQQ：如“第一季度”；默认为Q，为空则返回数字
 * @param {String} lang 语言zh和en，默认zh
 * @returns {Number,String} 返回第几季度，会根据语言返回
 */
declare function getQuarter(date?: Date, format?: string, lang?: string): number;
/**
 * 获得当前日期是所在周的第几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number|String} 返回天数
 */
declare function getDayOfWeek(date?: Date): number | string;
/**
 * 获得当前日期是所在月的第几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回天数
 */
declare function getDayOfMonth(date?: Date): number;
/**
 * 获得当前日期是所在年的第几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回天数
 */
declare function getDayOfYear(date?: Date): number;
/**
 * 获得当前日期是所在月的第几周
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回周数
 */
declare function getWeekOfMonth(date?: Date): number;
/**
 * 获得当前日期是所在年的第几周
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回周数
 */
declare function getWeekOfYear(date?: Date): number;
/**
 * 获得当前日期所在的周共几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回天数
 */
declare function getDaysOfWeek(date?: Date): number;
/**
 * 获得当前日期所在的月共几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回天数
 */
declare function getDaysOfMonth(date?: Date): number;
/**
 * 获得当前日期所在的年共几天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回天数
 */
declare function getDaysOfYear(date?: Date): number;
/**
 * 获得当前日期是所在月的第几周
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回周数
 */
declare function getWeeksOfMonth(date?: Date): number;
/**
 * 获得当前日期是所在年的第几周
 * @param {Date} date 日期参数，默认当前日期
 * @returns {Number} 返回周数
 */
declare function getWeeksOfYear(date?: Date): number;
/**
 * 获得当前日期所在周的第一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function getFirstDateOfWeek(date?: Date): string;
/**
 * 获得当前日期所在周的最后一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function getLastDateOfWeek(date?: Date): string;
/**
 * 获取当前日期所在周的所有日期
 */
declare function getFullDateOfWeek(date?: Date): string[];
/**
 * 获得当前日期所在月的第一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function getFirstDateOfMonth(date?: Date): string;
/**
 * 获得当前日期所在月的最后一天
 * @param {Date} date 日期参数，默认当前日期
 * @returns {String} 返回日期字符串
 */
declare function getLastDateOfMonth(date?: Date): string;
/**
 * 获取当前日期所在月的所有日期
 */
declare function getFullDateOfMonth(date?: Date): Date[];
/**
 * 获取当前日期所在年的第一天
 */
declare function getFirstDateOfYear(date?: Date): Date;
/**
 * 获取当前日期所在年的最后一天
 */
declare function getLastDateOfYear(date?: Date): Date;
/**
 * 获取当前日期所在年的所有日期
 */
declare function getFullDateOfYear(date?: Date): string[];
/**
 * 计算两个日期相差的天数，不满一天为0
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Number} 返回两个日期相差的天数，结果为正数或者负数
 */
declare function getDiffDay(startDate: Date, endDate: Date): number;
/**
 * 计算两个日期相差的周数，不满一周为0
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Number} 返回两个日期相差的周数，结果为正数或者负数
 */
declare function getDiffWeek(startDate: Date, endDate: Date): number;
/**
 * 计算两个日期相差的月数，不满一月为0
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Number} 返回两个日期相差的月数，结果为正数或者负数
 */
declare function getDiffMonth(startDate: Date, endDate: Date): number;
/**
 * 计算两个日期相差的年数，不满一年为0
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Number} 返回两个日期相差的年数，结果为正数或者负数
 */
declare function getDiffYear(startDate: Date, endDate: Date): number;
/**
 * 获得两个日期之间的年月日数组
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Array} 返回年月日数组
 */
declare function getBetweenDates(startDate: Date, endDate: Date): any[];
/**
 * 获得两个日期之间的年月数组
 * @description 支持：日期字符串，日期对象，时间戳，Unix时间戳
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Array} 返回年月数组
 */
declare function getBetweenMonths(startDate: Date, endDate: Date): any[];
/**
 * 获得两个日期之间的年数组
 * @param {Date} startDate 开始日期
 * @param {Date} endDate 结束日期
 * @returns {Array} 返回年数组
 */
declare function getBetweenYears(startDate: Date, endDate: Date): any[];
/**
 * 获得过去时间的字符串显示
 * @description 例如：刚刚，1分钟前，1小时前等
 * @param {Date} date 日期参数
 * @param {String} lang 语言zh和en，默认zh
 * @returns {String} 返回字符串
 */
declare function getPastTime(date: Date, lang?: string): string;
/**
 * 获得剩余时间的字符串显示
 * @description 例如：1天10小时20分钟30秒
 * @param {Date} date 日期参数
 * @param {String} lang 语言zh和en，默认zh
 * @returns {String} 返回字符串
 */
declare function getOverTime(date: Date, lang?: string): string;
/**
 * 通过日期获得年龄
 * @param {Date} date 日期参数
 * @returns {Number} 返回周岁年龄
 */
declare function getAge(date: Date): number;
/**
 * 通过日期获得星座
 * @param {Date} date 日期参数
 * @param {String} lang 语言zh和en，默认zh
 * @returns {String} 返回星座
 */
declare function getZodiac(date: Date, lang?: string): string;
/**
 * 通过日期获得生肖
 * @param {Date} date 日期参数
 * @param {String} lang 语言zh和en，默认zh
 * @returns {String} 返回生肖
 */
declare function getChineseZodiac(date: Date, lang?: string): string;
/**
 * 日期加减年
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addYear(date?: Date, num?: number): Date;
/**
 * 日期加减月
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addMonth(date?: Date, num?: number): Date;
/**
 * 日期加减天
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addDate(date?: Date, num?: number): Date;
/**
 * 日期加减小时
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addHours(date?: Date, num?: number): Date;
/**
 * 日期加减分钟
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addMinutes(date?: Date, num?: number): Date;
/**
 * 日期加减秒
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addSeconds(date?: Date, num?: number): Date;
/**
 * 日期加减毫秒
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+100
 * @returns {Date} 返回加减后的日期
 */
declare function addMillisecond(date?: Date, num?: number): Date;
/**
 * 日期加减周
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addWeek(date?: Date, num?: number): Date;
/**
 * 日期加减季度
 * @param {Date} date 日期参数，默认当前日期
 * @param {Number} num 加减数量，用正数和负数表示；默认+1
 * @returns {Date} 返回加减后的日期
 */
declare function addQuarter(date?: Date, num?: number): Date;
/**
 * 日期对象转为日期字符串
 * @description 支持日期字符串，日期对象，时间戳，unix时间戳
 * @param {String|Date|Number} date 日期参数
 * @param {String} format 转化格式
 * @param {String} lang 语言zh和en，默认zh
 * @returns {String} 返回日期字符串
 */
declare function formatDate(date: string | Date | number, format?: string, lang?: string): string;
/**
 * 日期字符串转为日期对象
 * @description 支持日期字符串，时间戳，Unix时间戳
 * @param {String|Number} value 日期参数
 * @returns {Date} 返回日期对象
 */
declare function parseDate(value: string | number): Date;

/**
 * 两个数字相加
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function add(arg1: string | number, arg2: string | number): number;
/**
 * 两个数字相减
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function subtract(arg1: string | number, arg2: string | number): number;
/**
 * 两个数字相乘
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns 返回计算后的数字
 */
declare function multiply(arg1: string | number, arg2: string | number): number;
/**
 * 两个数字相除
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function divide(arg1: string | number, arg2: string | number): number;
/**
 * 两个数字取模
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function modulo(arg1: string | number, arg2: string | number): number;
/**
 * 最大公约数
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function gcd(arg1: string | number, arg2: string | number): number;
/**
 * 最小公倍数
 * @param {String|Number} arg1 第一个数字
 * @param {String|Number} arg2 第二个数字
 * @returns {Number} 返回计算后的数字
 */
declare function scm(arg1: string | number, arg2: string | number): number;
/**
 * 强制保留小数位数
 * @description 默认保留两位小数，解决原生的toFixed()会五舍六入的问题
 * @param {String|Number} num 数字
 * @param {Number} decimals 保留小数的位数，默认2位
 * @param {Number} mode 保留小数模式
 * @returns {String} 返回保留后的数字字符串
 */
declare function toFixed(num: string | number, decimals?: number, mode?: number): string;
/**
 * 尽可能保留小数位数
 * @param {String|Number} num 数字
 * @param {Number} decimals 保留小数的位数，默认2位
 * @param {Number} mode 保留小数模式
 * @returns {Number} 返回保留后的数字
 */
declare function toDecimal(num: string | number, decimals?: number, mode?: number): number;

/**
 * 正则校验的方法
 * @description 类型为REGEXP对应的正则
 * @param {String|Number} value 校验的参数
 * @param {RegExp} regex 使用的REGEXP中的正则
 * @returns {Boolean} 返回校验的结果
 */
declare function regexpTest(value: string | number, regex: RegExp): boolean;
/**
 * 是中文
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isChinese(value: string): boolean;
/**
 * 是英文
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isEnglish(value: string): boolean;
/**
 * 是外链
 * @description 支持http，https，mail，tel电话
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isExternal(value: string): boolean;
/**
 * 是小写字母
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isLowerCase(value: string): boolean;
/**
 * 是大写字母
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isUpperCase(value: string): boolean;
/**
 * 是11位手机号码
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isMobile(value: string): boolean;
/**
 * 是邮箱
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isEmail(value: string): boolean;
/**
 * 是身份证号码（15-18位）
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isIdCard(value: string): boolean;
/**
 * 是url链接
 * @param {String} value 校验的参数
 * @returns {Boolean} 返回校验的结果
 */
declare function isUrl(value: string): boolean;

/**
 * 生成指定大小的随机整数
 * @description n和m参数表示最小和最大范围值，默认0-9之间范围
 * @param {Number} min 随机数的最小值，默认 0
 * @param {Number} max 随机数的最大值，默认 9
 * @returns {Number} 返回指定大小的随机整数
 */
declare function getRandom(min?: number, max?: number): number;
/**
 * 生成固定位数的随机整数
 * @description 默认是1，代表生成0-9之间一位，如果是2，则生成10-99之间两位，以此类推
 * @param {Number} len 固定的位数
 * @returns {Number} 返回固定位数的随机数
 */
declare function getRandomDigit(len?: number): number;

/**
 * 格式化文件大小自动转为 B，KB，MB，GB
 * @param {Number} size 文件的大小，单位byte字节
 * @returns {String} 返回格式化后的字符串
 */
declare function formatFileSize(size: number): string;
/**
 * 获得文件名称
 * @param {String} fileName 文件的全名称，例如：测试图片.jpg
 * @returns {String} 返回文件的名称
 */
declare function getFileName(fileName: string): string;
/**
 * 获得文件后缀名
 * @param {String} value 文件地址路径或者文件全名称，例如：http://xxx.com/mytest.jpg，测试图片.jpg
 * @returns {String} 返回文件后缀名
 */
declare function getFileSuffix(value: string): string;
/**
 * file转blob
 * @param {File} file file文件
 * @returns {Promise} 返回Promise的blob
 */
declare function fileToBlob(file: File): Promise<any>;
/**
 * file转base64
 * @param {File} file file文件
 * @returns {Promise} 返回Promise的base64
 */
declare function fileToBase64(file: File): Promise<any>;
/**
 * file转url
 * @description 适用于本地上传图片并预览，需要注意 URL.revokeObjectURL(file) 内存释放
 * @param {File} file file文件
 * @returns {Promise} 返回Promise的url
 */
declare function fileToUrl(file: File): Promise<any>;
/**
 * url赚file
 * @param {String} url url地址
 * @returns {Promise} 返回Promise的file
 */
declare function urlToFile(url: string): Promise<any>;
/**
 * blob转file
 * @param {Blob} blob blob数据
 * @param {String} fileName 文件名称，默认以时间戳命名
 * @returns {Promise} 返回Promise的file
 */
declare function blobToFile(blob: Blob, fileName?: string): Promise<any>;
/**
 * blob转文本
 * @param {Blob} blob blob数据
 * @returns {Promise} 返回Promise的文本
 */
declare function blobToText(blob: Blob): Promise<any>;
/**
 * blob转base64
 * @param {Blob} blob blob数据
 * @returns {Promise} 返回Promise的base64
 */
declare function blobToBase64(blob: Blob): Promise<any>;
/**
 * base64转file
 * @param {String} base64 base64数据
 * @param {String} fileName 文件名称，默认以时间戳命名
 * @returns {Promise} 返回Promise的file
 */
declare function base64ToFile(base64: string, fileName?: string): Promise<any>;
/**
 * base64转成blob
 * @param {String} base64 base64数据
 * @returns {Promise} 返回Promise的blob
 */
declare function base64ToBlob(base64: string): Promise<any>;
/**
 * 图片url转base64
 * @param {String} imgUrl 图片url地址
 * @returns {Promise} 返回Promise的base64
 */
declare function urlToBase64(imgUrl: string): Promise<any>;
/**
 * 下载blob格式的文件
 * @param {Blob} blob blob数据
 * @param {String} fileName 下载的文件名，不写后缀名则默认为原文件类型
 */
declare function downloadBlobFile(blob: Blob, fileName: string): void;
/**
 * 通过文件url地址下载
 * @param {String} fileUrl url文件地址
 * @param {String} fileName 下载的文件名，不写后缀名则默认为原文件类型
 */
declare function downloadFileUrl(fileUrl: string, fileName: string): void;

/**
 * rgb颜色转hex
 * @param {String} rgb rgb颜色字符串
 * @returns {String} 返回生成的hex颜色
 */
declare function rgbToHex(rgb: string): string;
/**
 * rgba颜色转hex
 * @param {String} rgba rgba颜色字符串
 * @returns {String} 返回生成的hex颜色
 */
declare function rgbaToHex(rgba: string): string;
/**
 * rgba颜色转hsl
 * @param {String} rgba rgb颜色字符串
 * @returns {String} 返回生成的hsl颜色
 */
declare function rgbaToHsl(rgba: string): string;
/**
 * hex颜色转rgb
 * @param {String} hex hex颜色字符串
 * @returns {String} 返回生成的rgb颜色
 */
declare function hexToRgb(hex: string): string;
/**
 * hex颜色转rgba
 * @param {String} hex hex颜色字符串
 * @param {Number} opacity 透明度
 * @returns {String} 返回生成的rgba颜色
 */
declare function hexToRgba(hex: string, opacity?: number): string;
/**
 * hex颜色转hsl
 * @param {String} hex hex颜色字符串
 * @returns {String} 返回生成的hsl颜色
 */
declare function hexToHsl(hex: string): string;
/**
 * 随机生成hex颜色
 * @returns {String} 返回生成的十六进制颜色
 */
declare function getDrawHex(): string;
/**
 * 随机生成rgb颜色
 * @returns {String} 返回生成的 rgb 颜色
 */
declare function getDrawRgb(): string;
/**
 * 随机生成rgba颜色
 * @returns {String} 返回生成的 rgba 颜色
 */
declare function getDrawRgba(): string;

/**
 * 判断是整数
 * @param {*} value 参数
 * @returns {Boolean} result 返回结果
 */
declare function isInteger(value: any): boolean;
/**
 * 判断是小数
 * @param {*} value 参数
 * @returns {Boolean} result 返回结果
 */
declare function isDecimal(value: any): boolean;
/**
 * 判断类型是数字 Number
 * @param {Number} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isNumber(value: number): boolean;
/**
 * 判断类型是字符串 String
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isString(value: any): boolean;
/**
 * 判断类型是数组 Array
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isArray(value: any): boolean;
/**
 * 判断类型是对象 Object
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isObject(value: any): boolean;
/**
 * 判断类型是布尔 Boolean
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isBoolean(value: any): boolean;
/**
 * 判断类型是日期 Date
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isDate(value: any): boolean;
/**
 * 判断类型是函数 Function
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isFunction(value: any): boolean;
/**
 * 判断类型是函数字符串 FunctionString
 * @description 支持普通函数，异步函数，箭头函数
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isFunctionString(value: any): boolean;
/**
 * 判断类型是异步函数 AsyncFunction
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isAsyncFunction(value: any): boolean;
/**
 * 判断类型是 Symbol
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isSymbol(value: any): boolean;
/**
 * 判断类型是正则 RegExp
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isRegExp(value: any): boolean;
/**
 * 判断类型是错误 Error
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isError(value: any): boolean;
/**
 * 判断类型是 Promise
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isPromise(value: any): boolean;
/**
 *判断类型是 Map
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isMap(value: any): boolean;
/**
 * 判断类型是 WeakMap
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isWeakMap(value: any): boolean;
/**
 * 判断类型是 Set
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isSet(value: any): boolean;
/**
 * 判断类型是 WeakSet
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isWeakSet(value: any): boolean;
/**
 * 判断类型是 BigInt
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isBigInt(value: any): boolean;
/**
 * 判断类型是 Json
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isJson(value: any): boolean;
/**
 * 判断值为真
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isTrue(value: any): boolean;
/**
 * 判断值为假
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isFalse(value: any): boolean;
/**
 * 判断非数字
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isNaN(value: any): boolean;
/**
 * 判断是数字
 * @description 等同于isNumber()
 * @param {*} value 参数
 * @returns {Boolean} 返回结果
 */
declare function isNotNaN(value: any): boolean;
/**
 * 判断对象为空
 * @description 判断值是否为空，如果对象初始化了值则不为空
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isNull(value: any): boolean;
/**
 * 判断对象不为空
 * @description 判断值是否为空，如果对象初始化了值则不为空
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isNotNull(value: any): boolean;
/**
 * 判断值为空
 * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isEmpty(value: any): boolean;
/**
 * 判断值不为空
 * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isNotEmpty(value: any): boolean;
/**
 * 判断值是空白的
 * @description 同时会校验空值，空对象，以及空白符号
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isBlank(value: any): boolean;
/**
 * 判断值不是空白的
 * @description 同时会校验空值，空对象，以及空白符号
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isNotBlank(value: any): boolean;
/**
 * 判断值是undefined
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isUndefined(value: any): boolean;
/**
 * 判断值不是undefined
 * @param {*} value 校验的参数
 * @returns {Boolean} 返回结果
 */
declare function isNotUndefined(value: any): boolean;
/**
 * 判断两个值是否相等
 * @param {String|Number} value1 参数1
 * @param {String|Number} value2 参数2
 * @returns {Boolean} 返回结果
 */
declare function equals(value1: string | number, value2: string | number): boolean;
/**
 * 判断两个值是否相等（忽略大小写）
 * @param {String|Number} value1 参数1
 * @param {String|Number} value2 参数2
 * @returns {Boolean} 返回结果
 */
declare function equalsIgnoreCase(value1: string | number, value2: string | number): boolean;
/**
 * 深度对比数据
 * @description 可以对比任意数据，对象，数组，日期等也可深度对比，对象不区分先后顺序
 * @param {*} x 数据1
 * @param {*} y 数据2
 * @returns {Boolean} 返回结果
 */
declare function deepCompare(x: any, y: any, ...args: any[]): boolean;

/**
 * 根据keycode获得键名
 * @param  {Number} keycode 键值
 * @returns {String} 返回键名
 */
declare function getKeyName(keycode: number): string;
/**
 * 根据keyname获得键值
 * @param  {Number} keyname
 * @returns {Number} 返回键值
 */
declare function getKeyCode(keyname: number): number;

/**
 * 生成UUID
 * @param {Number} len 生成的长度，默认32位
 * @param {Number} radix 进制数，默认16进制
 * @example
 * getUUID() // 输出：0a559343dbbf0e7e6c1de90163e7aa0a
 * @returns {String} 返回字符串
 */
declare function getUUID(len?: number, radix?: number): string;
/**
 * 生成GUID
 * @example
 * getGUID() // 输出：275ec770-0853-6767-4875-7b270220ce9c
 * @returns {String} 返回字符串
 */
declare function getGUID(): string;

/**
 * base64 加密
 * @param {String} str 字符串
 * @returns {String} 返回加密后的字符串
 */
declare function encode$1(str: string): string;
/**
 * base64 解密
 * @param {String} str 字符串
 * @returns {String} 返回解密后的字符串
 */
declare function decode$1(str: string): string;
/**
 * base64 utf8加密
 * @param {String} str 字符串
 * @returns {String} 返回加密后的字符串
 */
declare function utf8Encode(str: string): string;
/**
 * base64 utf8解密
 * @param {String} str 字符串
 * @returns {String} 返回解密后的字符串
 */
declare function utf8Decode(str: string): string;
/**
 * base64 加密字节数组
 * @param {Array} array 数组
 * @returns {String} 返回加密后的字符串
 */
declare function encodeAsBytes$1(array: any[]): string;
/**
 * base64 解密字节数组
 * @param {String} str 字符串
 * @returns {Array} 返回解密后的字节数组
 */
declare function decodeAsBytes$1(str: string): any[];

declare const index_d$7_utf8Decode: typeof utf8Decode;
declare const index_d$7_utf8Encode: typeof utf8Encode;
declare namespace index_d$7 {
  export {
    decode$1 as decode,
    decodeAsBytes$1 as decodeAsBytes,
    encode$1 as encode,
    encodeAsBytes$1 as encodeAsBytes,
    index_d$7_utf8Decode as utf8Decode,
    index_d$7_utf8Encode as utf8Encode,
  };
}

/**
 * base32 加密
 * @param {String} str 字符串
 * @returns {String} 返回加密后的字符串
 */
declare function encode(str: string