/**
 * 将两个数字相加
 *
 * @since 0.1.0
 * @category Math
 * @param {unknown} oneValue 运算中的第一个数字
 * @param {unknown} twoValue 运算中的第二个数字
 * @returns {number} 返回总和
 * @example
 *
 * add()
 * // => 0
 *
 * add(1, 2)
 * // => 3
 *
 * add(1)
 * // => 2
 */
export declare const add: Function;

/**
 * 小写连接符转换成驼峰
 *
 *
 * @since 0.1.0
 * @category Format
 * @param {string} word 处理的单词字符串
 * @param {string} [separator] 连接符，默认是 -
 * @returns {string} 返回格式化之后的单词
 * @example
 *
 * camelize('water-isVery-good')
 * // => 'waterIsVeryGood'
 *
 * camelize('water+isVery+good', '+')
 * // => 'waterIsVeryGood'
 *
 * camelize('水滴')
 * // => ''
 *
 * camelize('12222.22')
 * // => ''
 *
 * camelize('aaa')
 * // => ''
 */
export declare const camelize: (word?: unknown, separator?: string) => string;

/**
 * 克隆
 *
 *
 * @format
 * @since 0.1.0
 * @category Clone
 * @param {*} val 要复制的值。
 * @returns {any} 返回结果
 * @example
 *
 * clone([1,2,3,4])
 * // [1,2,3,4]
 *
 * clone({a: 1, b: 2})
 * // {a: 1, b: 2}
 *
 * clone(111)
 * // 111
 */
export declare const clone: (val: any) => any;

/**
 * 计算的基础
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {function} operator 执行操作的方法。
 * @param {number} [defaultValue] 参数默认值
 * @returns {Function} 返回新的数学运算函数。
 * @example
 *
 * count(augend, addend) => augend + addend, 0)(1, 2)
 * // => 3
 *
 * count(augend, addend) => augend + addend, 0)(1)
 * // => 2
 *
 * count(augend, addend) => augend + addend, 7)()
 * // => 7
 */
export declare const count: (operator: Function, defaultValue?: number) => Function;

/**
 * 创建 Storage
 *
 *
 * @since 0.4.0
 * @category Storage
 * @param {string} [prefixKey] 前缀
 * @param {string} [storage] 指定 storage 类型
 * @returns {WebStorage} 返回 WebStorage 对象
 * @example
 *
 * createStorage('prefixKey')
 *
 * reCamelize('prefixKey', sessionStorage)
 * // => /+(\w)/g
 *
 */
export declare const createStorage: ({ prefixKey, storage, }?: CreateStorageParams) => {
    storage: Storage;
    prefixKey?: string | undefined;
    /**
     * 获取 Storage 存储的 key
     *
     *
     * @since 0.4.0
     * @category Storage
     * @param {string} [key] key
     * @returns {string} 返回 存储的 key
     * @example
     *
     * getKey('prefixKey')
     *
     */
    getKey(key: string): string;
    /**
     * 设置 Storage
     *
     *
     * @since 0.4.0
     * @category Storage
     * @param {string} key key
     * @param {string} value value
     * @param {number} [expire] 过期时间，单位 秒 s
     * @returns {void} void
     * @example
     *
     * set('prefixKey'， 123)
     * set('prefixKey'， 123， 1000)
     *
     */
    set(key: string, value: any, exp?: unknown): void;
    /**
     * 获取 Storage
     * 过期了自动删除
     *
     * @since 0.4.0
     * @category Storage
     * @param {string} key key
     * @param {string} def 不存在 key 的默认返回
     * @returns {void} void
     * @example
     *
     * get('prefixKey'， 123)
     * get('prefixKey'， 123)
     *
     */
    get(key: string, def?: any): any;
    /**
     * 删除 key 的 Storage
     *
     * @since 0.4.0
     * @category Storage
     * @param {string} key key
     * @param {string} def 不存在 key 的默认返回
     * @returns {void} void
     * @example
     *
     * remove('prefixKey')
     *
     */
    remove(key: string): void;
    /**
     * Delete all caches of this instance
     */
    /**
     * 删除 所有 的 Storage
     *
     * @since 0.4.0
     * @category Storage
     * @returns {void} void
     * @example
     *
     * clear()
     *
     */
    clear(): void;
};

export declare interface CreateStorageParams {
    storage?: Storage;
    prefixKey?: string;
}

/**
 * 深度合并
 *
 *
 * @since 0.7.0
 * @category Object
 * @param {*} src 元对象
 * @param {*} target 目标对象
 * @returns {T} 返回新对象
 * @example
 *
 * deepMerge({ name: 'lee' }, { name: 'foo' })
 * // => { name: 'foo' }
 */
export declare function deepMerge<T = any>(src?: any, target?: any): T;

export declare const DEFAULT_CACHE_TIME: number;

/**
 * 将两个数字相除
 *
 * @since 0.1.0
 * @category Math
 * @param {unknown} oneValue 运算中的第一个数字
 * @param {unknown} twoValue 运算中的第二个数字
 * @returns {number} 返回总和
 * @example
 *
 * divide()
 * // => 1
 *
 * divide(1, 2)
 * // => 0.5
 *
 * divide(3)
 * // => 1
 */
export declare const divide: Function;

/**
 * 文件字节大小的转换
 *
 *
 * @since 0.1.0
 * @category Format
 * @param {number} num 要转换的大小
 * @returns {function} 返回带单位的大小
 * @example
 *
 * fileSize(1111)
 * // => {"size": 1.08, "unit": "KB"}
 *
 * fileSize(0)
 * // => {size: 0, unit: 'bytes'}
 */
export declare const fileSize: (num?: number | undefined) => {
    size: number;
    unit: string;
};

/**
 * 首字母大写
 *
 *
 * @since 0.1.0
 * @category Format
 * @param {string} word 处理的单词字符串
 * @returns {string} 返回格式化之后的单词
 * @example
 *
 * firstCapitalize(12222.22)
 * // => ''
 *
 * firstCapitalize('12222.22')
 * // => ''
 *
 * firstCapitalize('aaa')
 * // => 'Aaa'
 *
 * firstCapitalize('水滴aaa')
 * // => '水滴aaa'
 *
 * firstCapitalize('aaa水滴')
 * // => 'Aaa水滴'
 */
export declare const firstCapitalize: (word?: unknown) => string;

/**
 * 获取中英文字符串，中文占两个长度
 *
 * @since 0.9.0
 * @category Math
 * @param {unknown} oneValue 运算中的第一个数字
 * @param {unknown} twoValue 运算中的第二个数字
 * @returns {number} 返回总和
 * @example
 *
 * getStrLength()
 * // => 0
 *
 * getStrLength('水滴', '22')
 * // => 4
 *
 * getStrLength('water')
 * // => 5
 */
export declare const getStrLength: (str?: unknown, replaceValue?: string) => number;

/**
 * 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。
 *
 *
 * @since 0.1.0
 * @category Object
 * @param {*} item 目标对象
 * @param {string} attr 要检测的属性
 * @returns {boolean} 用来判断某个对象是否含有指定的属性的布尔值
 * @example
 *
 * hasOwn({ name: 'lee' }, 'name')
 * // => true
 *
 * hasOwn({ name: 'lee' }, 'age')
 * // => false
 */
export declare const hasOwn: (item: unknown, attr?: string | undefined) => boolean;

/**
 * 驼峰转换成小写连接符
 *
 *
 * @since 0.1.0
 * @category Format
 * @param {string} word 处理的单词字符串
 * @param {string} [separator] 连接符，默认是 -
 * @returns {string} 返回格式化之后的单词
 * @example
 *
 * hyphenate('111F')
 * // => '100-f'
 *
 * hyphenate('WaterIsVeryGood', '+')
 * // => 'water+is+very+good'
 *
 * hyphenate('水滴')
 * // => ''
 *
 * hyphenate('12222.22')
 * // => ''
 *
 * hyphenate('aaa')
 * // => ''
 */
export declare const hyphenate: (word?: unknown, separator?: string) => string;

/**
 * 是否是负整数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * inRange(3, 2, 4)
 * // => true
 *
 * inRange(4, 8)
 * // => true
 *
 * inRange(4, 2)
 * // => false
 *
 * inRange(2, 2)
 * // => false
 *
 * inRange(1.2, 2)
 * // => true
 *
 * inRange(5.2, 4)
 * // => false
 *
 * inRange(-3, -2, -6)
 * // => true
 */
export declare const inRange: (val?: unknown, start?: unknown, end?: unknown) => boolean;

/**
 * 是否是 Arguments
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isArguments('value')
 * // => false
 *
 * isArguments(123)
 * // => true
 */
export declare const isArguments: (val?: unknown) => boolean;

/**
 * 是否是数组
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isArray([1])
 * // => true
 *
 * isArray(123)
 * // => false
 */
export declare const isArray: (val?: unknown) => boolean;

/**
 * 是否是布尔值
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isBoolean(true)
 * // => true
 *
 * isBoolean(123)
 * // => false
 */
export declare const isBoolean: (val?: unknown) => boolean;

/**
 * 是否是浏览器端
 *
 *
 * @format
 * @since 0.1.0
 * @category Device
 * @returns {boolean} 返回结果
 * @example
 *
 * isClient()
 * // true
 */
export declare const isClient: () => boolean;

/**
 * 是否是 Date 对象
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isDate(new Date())
 * // => true
 *
 * isDate(123)
 * // => false
 */
export declare const isDate: (val?: unknown) => boolean;

/**
 * 是否是空对象，集合，映射或者set
 * 判断的依据是除非是有枚举属性的对象，length 大于 0 的 arguments object , array , string 。
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isEmpty(null);
 * // => true
 *
 * isEmpty(true);
 * // => true
 *
 * isEmpty(1);
 * // => true
 *
 * isEmpty([1, 2, 3]);
 * // => false
 *
 * isEmpty({ 'a': 1 });
 * // => false
 */
export declare const isEmpty: (val?: unknown) => boolean;

/**
 * 是否是小数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isFloat(100)
 * // => true
 *
 * isFloat(-12)
 * // => false
 */
export declare const isFloat: (val?: unknown) => boolean;

/**
 * 是否是函数
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isSymbol(Function)
 * // => true
 *
 * isSymbol(123)
 * // => false
 */
export declare const isFunction: (val?: unknown) => boolean;

/**
 * 是否是整数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isInteger(-100)
 * // => true
 *
 * isInteger(100)
 * // => true
 *
 * isInteger(12.3)
 * // => false
 *
 * isInteger(-12.3)
 * // => false
 */
export declare const isInteger: (val?: any) => boolean;

/**
 * 是否是 Map 对象
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isMap(new Map())
 * // => true
 *
 * isMap(123)
 * // => false
 */
export declare const isMap: (val?: unknown) => boolean;

/**
 * 是否是负数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isMinus(-100)
 * // => true
 *
 * isMinus(-100.11)
 * // => true
 *
 * isMinus(123)
 * // => false
 */
export declare const isMinus: (val?: unknown) => boolean;

/**
 * 是否是负整数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isMinusInteger(-100)
 * // => true
 *
 * isMinusInteger(12)
 * // => false
 */
export declare const isMinusInteger: (val?: unknown) => boolean;

/**
 * 是否是 NaN
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isNaN('f100')
 * // => true
 *
 * isNaN(123)
 * // => false
 */
declare const isNaN_2: (val?: unknown) => boolean;
export { isNaN_2 as isNaN }

/**
 * 是否是 null
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isNull(null)
 * // => true
 *
 * isNull(void 0)
 * // => false
 */
export declare const isNull: (val?: unknown) => boolean;

/**
 * 是否是数字
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isNumber('value')
 * // => false
 *
 * isNumber(123)
 * // => true
 */
export declare const isNumber: (val?: unknown) => boolean;

/**
 * 是否是普通对象
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isPlainObject({})
 * // => true
 *
 * isPlainObject(123)
 * // => false
 */
export declare const isPlainObject: (val?: unknown) => boolean;

/**
 * 是否是正整数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isPlusInteger(100)
 * // => true
 *
 * isPlusInteger(-12)
 * // => false
 */
export declare const isPlusInteger: (val?: unknown) => boolean;

/**
 * 是否是 promise
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isPromise(new Promise(function(a) {a()});)
 * // => true
 *
 * isPromise(123)
 * // => false
 */
export declare const isPromise: (val?: unknown) => boolean;

/**
 * 检查 'val' 是否可能是原型对象。
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isPrototype({a: 'as'})
 * // => true
 *
 * isPrototype(12)
 * // => false
 */
export declare const isPrototype: (val?: unknown) => boolean;

/**
 * 是否是 Set 对象
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isSet(new Set())
 * // => true
 *
 * isSet(123)
 * // => false
 */
export declare const isSet: (val?: unknown) => boolean;

/**
 * 是否是字符串
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isString('value')
 * // => true
 *
 * isString(123)
 * // => false
 */
export declare const isString: (val?: unknown) => boolean;

/**
 * 是否是 symbol
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isSymbol(Symbol())
 * // => true
 *
 * isSymbol(123)
 * // => false
 */
export declare const isSymbol: (val?: unknown) => boolean;

/**
 * 是否是 undefined
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isUndefined(undefined)
 * // => true
 *
 * isUndefined(123)
 * // => false
 */
export declare const isUndefined: (val?: unknown) => boolean;

/**
 * 是否是地址
 *
 *
 *
 * @since 0.5.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isUrl('http://www.water.com');
 * // => true
 *
 * isUrl('https://www.water.com');
 * // => true
 *
 * isUrl('https://www.water.com?good=true');
 * // => true
 *
 * isUrl(null);
 * // => false
 *
 * isUrl(false);
 * // => false
 *
 * isUrl(1);
 * // => false
 *
 * isUrl([1, 2, 3]);
 * // => false
 *
 * isUrl({ 'a': 1 });
 * // => false
 */
export declare function isUrl(path: unknown): boolean;

/**
 * 是否是 WeakSet 对象
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {boolean} 如果是返回 true ，否则返回 false
 * @example
 *
 * isWeakSet(new WeakSet())
 * // => true
 *
 * isWeakSet(123)
 * // => false
 */
export declare const isWeakSet: (val?: unknown) => boolean;

export declare const enum JS_TYPES {
    ARGUMENTS = "Arguments",
    NUMBER = "Number",
    STRING = "String",
    BOOLEAN = "Boolean",
    UNDEFINED = "Undefined",
    NULL = "Null",
    FUNCTION = "Function",
    SYMBOL = "Symbol",
    ARRAY = "Array",
    OBJECT = "Object",
    PROMISE = "Promise",
    SET = "Set",
    WEAKSET = "WeakSet",
    MAP = "Map",
    DATE = "Date"
}

export declare const keys: {
    (o: object): string[];
    (o: {}): string[];
};

/**
 * 获取类型简便方法
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {string} 字符串， 如 Number
 * @example
 *
 * like('value')
 * // => String
 *
 * like(123)
 * // => Number
 */
export declare const like: (val?: unknown) => string;

/**
 * 金额格式化
 * 必须得符合金钱的验证
 *
 * @since 0.1.0
 * @category Format
 * @param {string|number} money 金额
 * @param {boolean} [reverse] 是否反转， 如果存在并且为 true ',' 取消 ，的添加，否则是添加 ','
 * @returns {string} 返回格式化之后的金额
 * @example
 *
 * money(12222.22)
 * // => '12,222.22'
 *
 * money('12222.22')
 * // => '12,222.22'
 *
 * money('aaa')
 * // => ''
 *
 * money('12,222.22', true)
 * // => '12222.22'
 *
 * money('12,222.22')
 * // => '12222.22'
 */
export declare const money: (coin?: string | number, reverse?: boolean | undefined) => string;

/**
 * 将两个数字相乘
 *
 * @since 0.1.0
 * @category Math
 * @param {unknown} oneValue 运算中的第一个数字
 * @param {unknown} twoValue 运算中的第二个数字
 * @returns {number} 返回总和
 * @example
 *
 * multiply()
 * // => 1
 *
 * multiply(1, 2)
 * // => 2
 *
 * multiply(3)
 * // => 9
 */
export declare const multiply: Function;

/**
 * 对象转化为get请求的链接参数
 *
 *
 * @since 0.3.0
 * @category Object
 * @param {*} item 目标对象
 * @param {string} [baseUrl] 基本链接
 * @returns {string} 格式化好的字符串
 * @example
 *
 * objectToQuery({ name: 'www.baidu.com' }, 'www.water.com')
 * // => www.baidu.com?name=lee
 *
 * objectToQuery({a: '3', b: '4'})
 * // => a=3&b=4
 */
export declare const objectToQuery: (item: unknown, baseUrl?: string | undefined) => string;

/**
 * 对象转字符串方法
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {function} 返回方法
 * @example
 *
 * objectToString.call('value')
 * // => [object String]
 *
 * objectToString.call(123)
 * // => [object Number]
 */
export declare const objectToString: () => string;

/**
 * 手机号脱敏
 *
 *
 * @since 0.1.0
 * @category Format
 * @param {string|number} phone 手机号
 * @returns {string} 返回脱敏之后的手机号
 * @example
 *
 * phone(13810902078)
 * // => '138***2078'
 *
 * phone('13810902078')
 * // => '138***2078'
 *
 * phone('aaa')
 * // => ''
 */
export declare const phone: (codePhone?: string | number) => string;

/**
 * 获取一段区间内的随机数
 *
 *
 * @since 0.1.0
 * @category Number
 * @param {number} minValue 最小区间
 * @param {number} minValue 最大区间
 * @param {boolean} isFloat 是否是小数
 * @returns {number} 返回在最大最小区间内包括最大最小区间的整数
 * @example
 *
 * randomNumber(-100, 1)
 * // 生成 -100 到 1 之间的整数
 * // => 1
 *
 * randomNumber(12, 22)
 * // 生成 12 到 22 之间的整数
 * // => 12
 *
 * randomNumber(1, 3)
 * // 生成 1 到 3 之间的整数
 * // => 2
 *
 * randomNumber(1.1, 3.2)
 * // 生成 1.1 到 3.2 之间的小数
 * // => 2.2
 *
 * randomNumber(1, 3.2)
 * // 生成 1 到 3.2 之间的小数
 * // => 2.2
 *
 * randomNumber(1.1, 3)
 * // 生成 1 到 3 之间的小数
 * // => 2.2
 *
 * randomNumber(1, 3, true)
 * // 生成 1 到 3 之间的小数
 * // => 2.2
 */
export declare const randomNumber: (minValue: unknown, maxValue: unknown, isFloating?: boolean | undefined) => number;

/**
 * 获取 字母横线( 或其他 )转驼峰的正则
 *
 *
 * @since 0.1.0
 * @category Reg
 * @param {string} [separator] 连接符，默认是 -
 * @returns {RegExp} 返回正则
 * @example
 *
 * reCamelize()
 * // => /-(\w)/g;
 *
 * reCamelize('+')
 * // => /+(\w)/g
 *
 */
export declare const reCamelize: (separator?: unknown) => RegExp;

export declare const reEmail: RegExp;

export declare const reHyphenate: RegExp;

export declare const reLandlineAll: RegExp;

export declare const reLandlineAreaCode: RegExp;

export declare const reLandlineTel: RegExp;

export declare const reMoneyPrettify: RegExp;

export declare const reOnlyCn: RegExp;

export declare const reOnlyEnOrNum: RegExp;

export declare const rePhone: RegExp;

export declare const rePhone344: RegExp;

export declare const rePlusNumber: RegExp;

export declare const reUrl: RegExp;

export declare const reUrlInString: RegExp;

/**
 * 获取 url 问号后面的某一个值
 * @static
 * @since 1.0.7
 * @returns {string} Returns ''
 * @example
 *
 * url http://underline.com?underline=lee
 * var shallow = _.searchUrl('aaa');
 * console.log(shallow); // lee
 *
 * url http://underline.com?underline=lee
 * var shallow = _.searchUrl('em');
 * console.log(shallow); // ''
 *
 * url http://underline.com
 * var shallow = _.searchUrl('em');
 * console.log(shallow); // ''
 */
export declare function searchUrl(name: String): string;

export declare const enum SIZE_UNIT {
    KB = "KB",
    MB = "MB",
    GB = "GB",
    TB = "TB"
}

/**
 * 将两个数字相减
 *
 * @since 0.1.0
 * @category Math
 * @param {unknown} oneValue 运算中的第一个数字
 * @param {unknown} twoValue 运算中的第二个数字
 * @returns {number} 返回总和
 * @example
 *
 * subtract()
 * // => 0
 *
 * subtract(6, 4)
 * // => 2
 *
 * subtract(1, 2)
 * // => -1
 *
 * subtract(1)
 * // => 0
 */
export declare const subtract: Function;

/**
 * 获取类型通用方法
 *
 *
 * @since 0.1.0
 * @category Lang
 * @param {*} val 要检查的值。
 * @returns {string} 字符串， 如 [object Number]
 * @example
 *
 * toTypeString('value')
 * // => [object String]
 *
 * toTypeString(123)
 * // => [object Number]
 */
export declare const toTypeString: (value: unknown) => string;

/**
 * 生成32位码
 * @static
 * @since 0.1.0
 * @returns {string} 随机数
 * @example
 *
 * var shallow = _.guid();
 * console.log(shallow); // 359b53bab8ff1b0b1f7f9a32ac20c2aa
 */
export declare const uuid: () => string;

export { }