/**
 * 为日期增减给定的天数
 *
 * @param date 原始日期
 * @param amount 增减的天数
 *
 * @returns 修改后的日期
 */
export declare function addDays(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的半天数（12小时）
 *
 * @param date 原始日期
 * @param amount 增减的半天数
 *
 * @returns 修改后的日期
 */
export declare function addHalfDays(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的小时
 *
 * @param date 原始日期
 * @param amount 增减的小时
 *
 * @returns 修改后的日期
 */
export declare function addHours(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的毫秒
 *
 * @param date 原始日期
 * @param amount 增减的毫秒
 *
 * @returns 修改后的日期
 */
export declare function addMilliseconds(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的分钟
 *
 * @param date 原始日期
 * @param amount 增减的分钟
 *
 * @returns 修改后的日期
 */
export declare function addMinutes(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的月数
 *
 * @param date 原始日期
 * @param amount 增减的月数
 *
 * @returns 修改后的日期
 */
export declare function addMonths(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的季度（3个月）
 *
 * @param date 原始日期
 * @param amount 增减的季度
 *
 * @returns 修改后的日期
 */
export declare function addQuarters(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的秒
 *
 * @param date 原始日期
 * @param amount 增减的秒
 *
 * @returns 修改后的日期
 */
export declare function addSeconds(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的周数
 *
 * @param date 原始日期
 * @param amount 增减的周数
 *
 * @returns 修改后的日期
 */
export declare function addWeeks(date: Dateable, amount: number): Date;

/**
 * 为日期增减给定的年份
 *
 * @param date 原始日期
 * @param amount 增减的年份
 *
 * @returns 修改后的日期
 */
export declare function addYears(date: Dateable, amount: number): Date;

/**
 * 调整给定颜色值的透明度
 *
 * @param color 需要调整的颜色
 * @param alpha 调整后的透明度 0 ~ 1，0% ~ 100%
 *
 * @returns 调整后的颜色
 */
export declare function adjustAlpha(color: Color, alpha: number | string): RGBAColor;

/**
 * 将给定的常量字符串类型拓展为不区分大小写的任意组合
 */
export declare type AnyCase<S> = string extends S ? string : S extends `${infer F1}${infer F2}${infer R}` ? `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}` : S extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : '';

export declare interface BITree {
    tree: number[];
    /**
     * 为第 index 个元素增减值
     *
     * @param index 索引值
     * @param num 增减的值
     */
    add(index: number, num: number): void;
    /**
     * 求前 index 个元素的和
     *
     * @param index 索引值
     *
     * @returns 前 index 个元素的和
     */
    sum(index?: number): number;
    /**
     * 获取第 index 个元素的值
     *
     * @param index 索引值
     *
     * @returns 第 index 个元素的值
     */
    get(index: number): number;
    /**
     * 根据目标值寻找一个最接近的元素的索引值
     *
     * @param target 目标值
     *
     * @returns 最接近的元素的索引值
     */
    boundIndex(target: number): number;
}

/**
 * 将给定的数字限定在指定的范围内
 *
 * @param number 需要限定范围的数
 * @param min 边界最小值，包含该值
 * @param max 边界最大值，包含该值
 *
 * @returns 限定在范围内的值
 */
export declare function boundRange(number: number | string, min: number, max: number): number;

/**
 * 如果一个值为函数，则执行它并返回结果，否则返回其本身
 *
 * @param value 指定的值
 * @param args 若为函数时，传入的参数
 *
 * @returns 原始值或函数执行结果
 */
export declare function callIfFunc<T, P extends any[] = any[]>(value: T | ((...args: P) => T), ...args: P): T;

/**
 * 将给定的常量字符串类型拓展为大驼峰
 */
export declare type CapitalCase<T extends string> = T extends `${infer First} ${infer Rest}` ? CapitalCase<`${First}-${Rest}`> : T extends `${infer First}-${infer Rest}` ? `${Capitalize<First>}${CapitalCase<Rest>}` : Capitalize<T>;

/**
 * 当前点击的类型，可以使用触摸交互时为 `pointerdown`，否则为 `click`
 */
export declare const CLICK_TYPE: string;

export declare type Color = string | RGBColor | RGBAColor | HSLColor | HSLAColor | HSVColor | HSVAColor | HEX3Color | HEX4Color | HEX6Color | HEX8Color;

export declare const COLOR_NAMES: Readonly<Set<ColorName>>;

export declare interface ColorMeta {
    rgb: RGBColor;
    hsl: HSLColor;
    hsv: HSVColor;
    hex: string;
    alpha: number;
    rgba: RGBAColor;
    hsla: HSLAColor;
    hsva: HSVAColor;
    hex8: string;
    gray: number;
    origin: Color;
}

export declare type ColorName = keyof typeof NAMED_COLORS;

export declare type ColorType = 'hex' | 'rgb' | 'hsv' | 'hsl';

/**
 * 升序比较两个日期大小，用于给数组的 sort 方法使用
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 比较后的结果，`-1` 则左侧小，`1` 则右侧小，`0` 则相等
 */
export declare function compareAsc(left: Dateable, right: Dateable): number;

/**
 * 降序比较两个日期大小，用于给数组的 sort 方法使用
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 比较后的结果，`1` 则左侧小，`-1` 则右侧小，`0` 则相等
 */
export declare function compareDesc(left: Dateable, right: Dateable): number;

/**
 * 判断一个元素是否包含另一个元素
 *
 * @param el 被包含的元素（子元素）
 * @param parent 包含的元素（父元素）
 *
 * @returns 元素是否包含另一个元素
 */
export declare function contains(el?: Element | null, parent?: HTMLElement | null): boolean;

/**
 * 创建一个二叉索引树（Fenwick 树）对象
 *
 * 为了节省初始化性能开销，需确保元素最小值已知，其初始值为：元素最小值 * 元素总数
 *
 * @param length 树的大小，即元素的总数
 * @param min 规定元素的最小值
 *
 * @returns 二叉索引树对象
 */
export declare function createBITree(length: number, min?: number): BITree;

export declare function createCounter(count?: number): {
    getCount: () => number;
    setCount: (newCount: number) => void;
};

/**
 * 创建一个自定义的事件发射器
 *
 * @returns 事件发射器
 */
export declare function createEventEmitter(): EventEmitter;

export declare type Dateable = number | string | Date;

export declare const DAY_ON_HOURS = 24;

export declare const DAY_ON_MILLISECONDS: number;

/** @deprecated renames to `DAY_ON_MILLISECONDS` */
export declare const DAY_ON_MILLS: number;

export declare const DAY_ON_MINUTES: number;

export declare const DAY_ON_SECONDS: number;

/**
 * 将一个方法进行防抖
 *
 * @param method 需要防抖的方法，需自行绑定 this
 * @param delay 防抖的限制时间，默认 100ms
 *
 * @returns 防抖后的方法
 */
export declare function debounce<T extends (...args: any[]) => any>(method: T, delay?: number): (...args: Parameters<T>) => void;

/**
 * 对给定的方法进行渲染帧级别的防抖
 *
 * @param method 需要防抖的方法，需自行绑定 this
 *
 * @returns 防抖后的方法
 */
export declare function debounceFrame<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;

/**
 * 对给定的方法进行微任务级别的防抖
 *
 * @param method 需要防抖的方法，需自行绑定 this
 *
 * @returns 防抖后的方法
 */
export declare function debounceMinor<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;

/**
 * 根据一系列判断条件，执行第一个为 `true` 的条件所对应的回调函数
 *
 * @param conditions 判断条件及回调函数
 * @param options 额外的选项
 *
 * @returns 是否匹配了任一条件
 */
export declare function decide(conditions: [boolean | (() => boolean), () => void | Promise<void>][], options?: {
    /**
     * 当匹配任意一个条件时，会在该条件对应的回调函数执行前执行
     */
    beforeMatchAny?: () => void | Promise<void>;
    /**
     * 当匹配任意一个条件时，会在该条件对应的回调函数执行完后执行
     */
    afterMatchAny?: () => void | Promise<void>;
}): Promise<boolean>;

/**
 * 返回数字的小数位数
 *
 * @param number 指定的数字
 *
 * @returns 数字的小数位数
 */
export declare function decimalLength(number: number | string): number;

/**
 * 深度拷贝对象或数组
 *
 * @param obj 需要拷贝的对象或数组
 *
 * @returns 克隆后的对象
 */
export declare function deepClone<T>(obj: T, options?: DeepCloneOptions): T;

export declare interface DeepCloneOptions {
    /**
     * 一个自定义的克隆对象方法，用于处理方法内置以外的对象克隆，如 Class 的实例
     *
     * @param type 对象的类型，注意格式为大驼峰
     * @param obj 原始对象
     *
     * @returns 克隆后对象
     */
    cloneObject?: (type: string, obj: unknown) => any;
}

/**
 * 将一个对象销毁，销毁后的对象所有方法不可用，属性值均为 `null`
 *
 * @param object 要销毁的对象
 * @param message 销毁后，调用方法时的错误信息
 */
export declare function destroyObject(object: any, message?: string): void;

/**
 * 比较两个日期相差的天数
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的天数
 */
export declare function differenceDays(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整天
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整天数
 */
export declare function differenceFullDays(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整小时
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整小时数
 */
export declare function differenceFullHours(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整分钟
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整分钟数
 */
export declare function differenceFullMinutes(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整月
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整月份
 */
export declare function differenceFullMonths(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整季度
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整季度
 */
export declare function differenceFullQuarters(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整秒
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整秒数
 */
export declare function differenceFullSeconds(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整周
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整周数
 */
export declare function differenceFullWeeks(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的完整年份
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的完整年份
 */
export declare function differenceFullYears(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的小时
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的小时数
 */
export declare function differenceHours(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的毫秒
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的毫秒数
 */
export declare function differenceMilliseconds(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的分钟
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的分钟数
 */
export declare function differenceMinutes(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的月
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的月份
 */
export declare function differenceMonths(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的季度
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的季度
 */
export declare function differenceQuarters(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的秒
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的秒数
 */
export declare function differenceSeconds(left: Dateable, right: Dateable): number;

/**
 * 比较两个日期相差的周
 *
 * @param left 原始日期
 * @param right 原始日期
 * @param weekStartOn 设定周的第一天，默认为周日
 *
 * @returns 相差的周数
 */
export declare function differenceWeeks(left: Dateable, right: Dateable, weekStartOn?: number): number;

/**
 * 比较两个日期相差的年份
 *
 * @param left 原始日期
 * @param right 原始日期
 *
 * @returns 相差的年份
 */
export declare function differenceYears(left: Dateable, right: Dateable): number;

/**
 * Return decimal length of a number
 *
 * @param number The input number
 * @deprecated Using `decimalLength` to replace it
 */
export declare function digitLength(number: number | string): number;

/**
 * 为指定的元素派发事件
 *
 * @param el 指定的元素
 * @param payload 事件的属性
 * @param Event 事件类
 *
 * @returns 事件是否派发成功
 */
declare function dispatchEvent_2(el: Element, payload: EventPayload, Event?: {
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}): boolean;
export { dispatchEvent_2 as dispatchEvent }

/**
 * 精确的除法
 *
 * @param numbers 需要依次相除的数字
 *
 * @returns 商
 */
export declare const divide: (...numbers: (number | string)[]) => number;

/**
 * 将小于 10 整数 N 变成 `0N` 的字符串，方法不会对入参校验
 *
 * @param number 需要处理的整数
 *
 * @returns 填充后的字面值
 */
export declare function doubleDigits(number: number): string;

/**
 * 获取给定日期所在天的结束日期
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function endOfDay(date: Dateable): Date;

/**
 * 如果一个值不为数组，则将其转换为数组
 *
 * @param value 指定的值
 *
 * @returns 原始数组或转换后的数组
 */
export declare function ensureArray<T>(value: T | T[]): T[];

/**
 * 仅发出一次的错误消息
 *
 * @param message 消息内容
 * @param logFn 输出函数
 */
export declare function errorOnce(message: string, logFn?: (...data: any[]) => void): void;

/**
 * 将 html 内容的敏感字符进行转换
 *
 * @param string html 内容
 *
 * @returns 转换后的 html 内容
 */
export declare function escapeHtml(string: unknown): string;

export declare interface EventEmitter {
    /**
     * 为指定的事件添加回调方法
     *
     * @param type 事件类型
     * @param handler 回调方法
     */
    on: (type: EventType, handler: EventHandler) => void;
    /**
     * 为指定的事件移除回调方法
     *
     * @param type 事件类型
     * @param handler 回调方法
     */
    off: (type: EventType, handler: EventHandler) => void;
    /**
     * 为指定的事件清除所有回调方法
     *
     * @param type 事件类型
     */
    clear: (type: EventType) => void;
    /**
     * 清除所有事件的所有回调方法
     */
    clearAll: () => void;
    /**
     * 派发特定的事件
     *
     * @param type 事件类型
     * @param payload 传入事件回调方法的参数
     */
    emit: (type: EventType, ...payload: any[]) => void;
}

export declare type EventHandler = (...payload: any[]) => void;

export declare type EventHandlerMap = Map<EventType, EventHandlerSet>;

export declare type EventHandlerSet = Set<EventHandler>;

export declare interface EventPayload extends EventInit {
    /**
     * 事件的类型
     */
    type: string;
    [prop: string]: any;
}

export declare type EventType = number | string | symbol;

/**
 * 遍历树并为每个节点执行过滤方法，并用符合条件的节点构建一棵新的树
 *
 * @param tree 要遍历的树
 * @param cb 过滤的方法
 * @param options 遍历的配置项
 *
 * @returns 过滤后新的树
 */
export declare function filterTree<T = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => boolean, options?: {
    /** 判断一个节点是否为叶子节点 */
    isLeaf?: (item: T) => boolean;
    /** 是否只对叶子节点进行过滤 */
    leafOnly?: boolean;
    childField?: keyof T;
}): T[];

/**
 * 将一个树展平成列表
 *
 * @param tree 要展平的树
 * @param options 转换的配置项
 *
 * @returns 展平后的列表
 */
export declare function flatTree<T = any>(tree: T[], options?: TreeOptions<keyof T> & {
    /** 是否为深度优先遍历 */
    depthFirst?: boolean;
    /**
     * 是否为无 ID 的节点插入 ID 值
     *
     * @default true
     */
    injectId?: boolean;
    /** 构建节点的 ID 的方法 */
    buildId?: (index: number) => any;
    /** 过滤节点的方法 */
    filter?: (item: T) => boolean;
    /** 过滤的结果是否会影响其子级 */
    cascaded?: boolean;
    /** 是否强制为节点插入 ID 值 */
    forceInject?: boolean;
}): T[];

/**
 * 将日期格式化成指定格式
 *
 * @param date 需要格式化的Date对象
 * @param pattern 格式化结构 年-y 月-M 日-d 时-H 分-m 秒-s 季度-q
 *
 * @returns 格式化后的字面值
 *
 * @example
 * ```ts
 * format(new Date(), 'yyyy-MM-dd')
 * ```
 *
 * @example
 * ```ts
 * format(Date.now(), 'yyyy-MM-dd\'T\'HH:mm:ss\'Z\'')
 * ```
 */
export declare function format(date: Dateable, pattern?: string): string;

/**
 * 根据给定的 Byte 数值，将其格式化成指定单位的大小
 *
 * @param byte 需要计算的 Byte 数值
 * @param unit 格式化的单位
 * @param precision 结果的精度
 * @param joinUtil 是否加入单位
 *
 * @returns 格式化后的值
 */
export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto): number;

export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, precision?: number): number;

export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true): number;

export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true, precision?: number): number;

/**
 * 获取中文星期
 *
 * @param date 给定的日期
 *
 * @returns 中文星期
 */
export declare function getChineseWeek(date: Date): string;

export declare function getGlobalCount(): number;

/**
 * 获取字符串的最后一个字符
 *
 * @param value 指定的字符串
 *
 * @returns 最后一个字符
 */
export declare function getLast(value: string): string | undefined;

/**
 * 获取数组的最后一个元素
 *
 * @param value 指定的数组
 *
 * @returns 最后一个元素
 */
export declare function getLast<T>(value: T[]): T | undefined;

/**
 * 获取给定年份和月份的最后一天
 *
 * @param year 原始年份
 * @param month 原始月份
 *
 * @returns 最后一天
 */
export declare function getLastDayOfMonth(year: number, month: number): number;

/**
 * 根据给定的日期获取上一个周日
 *
 * @param date 原始日期
 *
 * @returns 上一个周日
 */
export declare function getLastSunday(date: Date): Date;

/**
 * 获取日期所在的季度
 *
 * @param date 给定的日期
 *
 * @returns 日期所在的季度
 */
export declare function getQuarter(date: Dateable): number;

/**
 * 获取元素的选中宽度
 *
 * @param el 指定的元素
 *
 * @returns 元素的选中宽度
 */
export declare function getRangeWidth(el: HTMLElement | null): number;

/**
 * 获取日期的时间部分
 *
 * @param date 给定的日期
 *
 * @returns 日期的时间部分
 */
export declare function getTime(date: Dateable): string;

/**
 * 获取变量的类型
 *
 * @param value 任意变量
 *
 * @returns 变量的类型
 */
export declare function getType(value: unknown): string;

/**
 * 获取元素横向的边框像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素横向的边框像素值
 */
export declare function getXBorder(el: HTMLElement | null): number;

/**
 * 获取元素横向的外边距像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素横向的外边距像素值
 */
export declare function getXMargin(el: HTMLElement | null): number;

/**
 * 获取元素横向的内边距像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素横向的内边距像素值
 */
export declare function getXPadding(el: HTMLElement | null): number;

/**
 * 获取元素纵向的边框像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素纵向的边框像素值
 */
export declare function getYBorder(el: HTMLElement | null): number;

/**
 * 获取元素纵向的外边距像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素纵向的外边距像素值
 */
export declare function getYMargin(el: HTMLElement | null): number;

/**
 * 获取元素纵向的内边距像素值
 *
 * @param el 指定的元素
 *
 * @returns 元素纵向的内边距像素值
 */
export declare function getYPadding(el: HTMLElement | null): number;

/**
 * 按照一定顺序的属性对数据进行分组
 *
 * @param list 需要分数的数据
 * @param props 需要按顺序分组的属性
 *
 * @returns 分组后的对象
 */
export declare function groupByProps<T = any>(list: T[], props?: Array<string | ((item: T) => any)> | string | ((item: T) => any)): Record<string, T[]>;

/**
 * 判断一个对象是否包含指定的键值
 *
 * @param value 需判断的对象
 * @param key 指定的键值
 *
 * @returns 是否包含键值
 */
export declare function has(value: Record<string, any>, key: string | symbol): key is keyof typeof value;

export declare interface HEX3Color extends RGB {
    a?: 1;
    format?: 'name' | 'hex3';
}

export declare interface HEX4Color extends RGB {
    a: number;
    format?: 'name' | 'hex4';
}

export declare interface HEX6Color extends RGB {
    a?: 1;
    format?: 'name' | 'hex6';
}

export declare interface HEX8Color extends RGB {
    a: number;
    format?: 'name' | 'hex8';
}

export declare const HEX_REG_3: RegExp;

export declare const HEX_REG_4: RegExp;

export declare const HEX_REG_6: RegExp;

export declare const HEX_REG_8: RegExp;

export declare const HOUR_ON_MILLISECONDS: number;

/** @deprecated renames to `HOUR_ON_MILLISECONDS` */
export declare const HOUR_ON_MILLS: number;

export declare const HOUR_ON_MINUTES = 60;

export declare const HOUR_ON_SECONDS: number;

declare interface HSL extends Record<any, any> {
    h: number;
    s: number;
    l: number;
    a?: number;
}

export declare const HSL_REG: RegExp;

export declare const HSLA_REG: RegExp;

export declare interface HSLAColor extends HSL {
    a: number;
    format?: 'name' | 'hsla';
}

export declare interface HSLColor extends HSL {
    a?: 1;
    format?: 'name' | 'hsl';
}

/**
 * 将 HSL 颜色转换为 HSV 颜色
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param l 0 ~ 1，0% ~ 100%
 *
 * @returns 转换后的 HSV 颜色
 */
export declare function hslToHsv(h: number | string, s: number | string, l: number | string): HSVColor;

/**
 * 将 HSL 颜色转换为 RGB 颜色
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param l 0 ~ 1，0% ~ 100%
 *
 * @returns 转换后的 RGB 颜色
 */
export declare function hslToRgb(h: number | string, s: number | string, l: number | string): RGBColor;

declare interface HSV extends Record<any, any> {
    h: number;
    s: number;
    v: number;
    a?: number;
}

export declare const HSV_REG: RegExp;

export declare const HSVA_REG: RegExp;

export declare interface HSVAColor extends HSV {
    a: number;
    format?: 'name' | 'hsva';
}

export declare interface HSVColor extends HSV {
    a?: 1;
    format?: 'name' | 'hsv';
}

/**
 * 将 HSV 颜色转换为 HSL 颜色
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param v 0 ~ 1，0% ~ 100%
 *
 * @returns 转换后的 HSL 颜色
 */
export declare function hsvToHsl(h: number | string, s: number | string, v: number | string): HSLColor;

/**
 * 将 HSV 颜色转换为 RGB 颜色
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param v 0 ~ 1，0% ~ 100%
 *
 * @returns 转换后的 RGB 颜色
 */
export declare function hsvToRgb(h: number | string, s: number | string, v: number | string): RGBColor;

/**
 * 仅发出一次的提示消息
 *
 * @param message 消息内容
 * @param logFn 输出函数
 */
export declare function infoOnce(message: string, logFn?: (...data: any[]) => void): void;

/**
 * 判断一个值是否为指定的类型
 *
 * @param value 需判断的值
 * @param type 指定的类型，注意大小写
 *
 * @returns 类型是否匹配
 */
export declare function is(value: unknown, type: string): boolean;

/**
 * 判断一个值是否为数组
 *
 * @param value 需判断的值
 *
 * @returns 是否为数组
 */
export declare function isArray<T = any>(value: unknown): value is T[];

/**
 * 判断一个值是否为 `BigInt`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `BigInt`
 */
export declare function isBigInt(value: unknown): value is bigint;

/**
 * 判断一个值是否为布尔值
 *
 * @param value 需判断的值
 *
 * @returns 是否为布尔值
 */
export declare function isBoolean(value: unknown): value is boolean;

/** 当前环境是否为客户端 */
export declare const isClient: boolean;

/**
 * 判断给定的字符串是否为一个合法颜色值
 *
 * @param value 原始字符串
 *
 * @returns 是否为合法颜色
 */
export declare function isColor(value: string): boolean;

/**
 * 判断一个值是否为 `Date`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `Date`
 */
export declare function isDate(value: unknown): value is Date;

/**
 * 判断一个值是否已定义
 *
 * @param value 需判断的值
 *
 * @returns 是否已定义
 */
export declare function isDefined<T = unknown>(value: T | undefined | null): value is Exclude<T, undefined | null>;

/**
 * 判断指定的元素是否被禁用
 *
 * @param el 需判断的元素
 *
 * @returns 元素是否被禁用
 */
export declare function isDisabled(el?: Element | null): boolean;

/**
 * 判断一个值是否为 `Element`
 *
 * @param value 需判断的值
 * @param ssr 是否考虑服务端渲染
 *
 * @returns 是否为 `Element`
 */
export declare function isElement<T extends Element = Element>(value: unknown, ssr?: boolean): value is T;

/**
 * 判断一个值是否为空
 *
 * - 如果这是一个数组或字符串，则 `length` 为 `0` 时为空
 * - 如果这是一个 `Set` 或 `Map`，则 `size` 为 `0` 时为空
 * - 如果这是一个对象，则无任何键值时为空
 * - 如果这是一个数字，则为 `NaN` 时为空
 * - 其余情况下，未定义时为空
 *
 * @param value 需判断的值
 *
 * @returns 是否为空
 */
export declare function isEmpty(value: unknown): boolean;

/**
 * 判断一个值是否为 `false`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `false`
 */
export declare function isFalse(value: unknown): value is false;

/**
 * 判断指定的元素是否聚焦或包含聚焦的元素
 *
 * @param el 需判断的元素
 *
 * @returns 是否聚焦或包含聚焦的元素
 */
export declare function isFocusIn(el?: Element | null): boolean;

/**
 * 判断一个值是否为函数
 *
 * @param value 需判断的值
 *
 * @returns 是否为函数
 */
export declare function isFunction(value: unknown): value is (...any: any[]) => any;

/**
 * 判断指定的元素是否隐藏
 *
 * @param el 需判断的元素
 *
 * @returns 元素是否隐藏
 */
export declare function isHidden(el?: Element | null): boolean;

/** 当前环境是否为 IOS */
export declare const isIOS: boolean | "";

/**
 * 判断一个值能否被迭代
 *
 * @param value 需判断的值
 *
 * @returns 能否被迭代
 */
export declare function isIterable(value: unknown): boolean;

/**
 * 判断给定的年份是否为闰年
 *
 * @param year 原始年份
 *
 * @returns 是否为闰年
 */
export declare function isLeapYear(year: number): boolean;

/**
 * 判断一个值是否为 `Map`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `Map`
 */
export declare function isMap<K = any, V = any>(value: unknown): value is Map<K, V>;

/**
 * 判断一个值是否为 `NaN`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `NaN`
 */
declare function isNaN_2(value: unknown): value is number;
export { isNaN_2 as isNaN }

/**
 * 判断一个值是否未被定义
 *
 * @param value 需判断的值
 *
 * @returns 是否未定义
 */
export declare function isNull(value: unknown): value is null | undefined;

/**
 * 判断一个值是否为数字
 *
 * @param value 需判断的值
 *
 * @returns 是否为数字
 */
export declare function isNumber(value: unknown): value is number;

/**
 * 判断一个值是否为对象
 *
 * 注意，`null` 与原生的特殊对象不被包含
 *
 * @param value 需判断的值
 *
 * @returns 是否为对象
 */
export declare function isObject<T extends Record<any, any> = Record<any, any>>(value: unknown): value is T;

/**
 * 判断一个值是否为 `Promise`
 *
 * 如果一个对象包含 `then` 和 `catch` 方法，则被认为是一个 `Promise`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `Promise`
 */
export declare function isPromise<T = any>(value: unknown): value is Promise<T>;

/**
 * 判断一个值是否为正则
 *
 * @param value 需判断的值
 *
 * @returns 是否为正则
 */
export declare function isRegExp(value: unknown): value is RegExp;

/**
 * 判断一个值是否为 `Set`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `Set`
 */
export declare function isSet<T = any>(value: unknown): value is Set<T>;

/**
 * 判断一个值是否为字符串
 *
 * @param value 需判断的值
 *
 * @returns 是否为字符串
 */
export declare function isString(value: unknown): value is string;

/**
 * 判断一个值是否为 `Symbol`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `Symbol`
 */
export declare function isSymbol(value: unknown): value is symbol;

/**
 * 判断一个值是否为 `true`
 *
 * @param value 需判断的值
 *
 * @returns 是否为 `true`
 */
export declare function isTrue(value: unknown): value is true;

/**
 * 检测给定的值是否可以通过 parseFlat 或 Number 方法转为数字
 *
 * 开启严格模式则通过正则以更严格的方法判断
 *
 * @param value 需要检测的值
 * @param strict 是否为严格模式
 *
 * @returns 值是否可以转为数字
 */
export declare function isValidNumber(value: unknown, strict?: boolean): boolean;

/**
 * 判断指定的元素是否可见
 *
 * @param el 需判断的元素
 *
 * @returns 元素是否可见
 */
export declare function isVisible(el?: Element | null): boolean;

/**
 * 将给定的被除数和除数，不断的取余直至达到次数限制或余数小于除数，返回系列余数
 *
 * @param number 被除数，需大于 0
 * @param divideBy 除数，需大于 1
 * @param limit 次数限制，默认为 0，小于 1 则不作限制
 *
 * @returns 相除过程的系列余数
 */
export declare function leaveNumber(number: number, divideBy: number, limit?: number): number[];

declare function listToMap<T = any, K extends keyof T = keyof T>(list: T[], prop: K, useMap?: false): Record<T[K] extends RecordKey ? T[K] : RecordKey, T>;

declare function listToMap<T = any, O = T, K extends keyof T = keyof T>(list: T[], prop: K, accessor?: (item: T) => O, useMap?: false): Record<T[K] extends RecordKey ? T[K] : RecordKey, O>;

declare function listToMap<T = any, K = RecordKey>(list: T[], prop: (item: T) => K, useMap?: false): Record<K extends RecordKey ? K : RecordKey, T>;

declare function listToMap<T = any, O = T, K = RecordKey>(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, useMap?: false): Record<K extends RecordKey ? K : RecordKey, O>;

declare function listToMap<T = any, K extends keyof T = keyof T>(list: T[], prop: K, useMap?: true): Map<T[K], T>;

declare function listToMap<T = any, O = T, K extends keyof T = keyof T>(list: T[], prop: K, accessor?: (item: T) => O, useMap?: true): Map<T[K], O>;

declare function listToMap<T = any, K = any>(list: T[], prop: (item: T) => K, useMap?: true): Map<K, T>;

declare function listToMap<T = any, O = T, K = any>(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, useMap?: true): Map<K, O>;
export { listToMap }
export { listToMap as transformListToMap }

/**
 * 遍历树并为每个节点执行回调方法，并用其返回值构建一颗新的树
 *
 * @param tree 要遍历的树
 * @param cb 回调函数
 * @param options 遍历的配置项
 *
 * @returns 构建后新的树
 */
export declare function mapTree<T = any, R = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => R, options?: {
    /** 是否为深度优先遍历 */
    depthFirst?: boolean;
    childField?: keyof T;
    /** 是否强制重置 `children` 字段 */
    clearChildren?: boolean;
}): R[];

/**
 * 将两个对象进行深度的动态合并
 *
 * @param sourceObj 用于接收合并的源对象
 * @param targetObj 被合并的对象，当属性名相同但值类型不同的情况，此对象的权重更高
 * @param isNewObj 标记合并至一个全新的对象（深度的）
 *
 * @returns 合并后的对象
 */
export declare function mergeObjects<T extends Record<string, any>, U extends Record<string, any>>(sourceObj: T, targetObj: U, isNewObj?: boolean): T & U;

/**
 * 精确的减法
 *
 * @param numbers 需要依次相减的数字
 *
 * @returns 差值
 */
export declare const minus: (...numbers: (number | string)[]) => number;

export declare const MINUTE_ON_MILLISECONDS: number;

/** @deprecated renames to `MINUTE_ON_MILLISECONDS` */
export declare const MINUTE_ON_MILLS: number;

export declare const MINUTE_ON_SECONDS = 60;

/**
 * 将两种颜色按照一定的比例混合
 *
 * @param color1 第一种颜色
 * @param color2 第二种颜色
 * @param weight 混合比例 0 ~ 1，越小则第一种颜色越少
 *
 * @returns 混合后的颜色
 */
export declare function mixColor(color1: Color, color2: Color, weight?: number): RGBAColor;

/**
 * 将给定的实数扩大一定的倍数并保留一定的小数
 *
 * @param number 要处理的实数
 * @param multiple 要扩大的倍数
 * @param decimal 要保留的小数
 *
 * @returns 扩大并保留小数后的值
 */
export declare function multipleFixed(number: number, multiple: number, decimal: number): number;

export declare const NAMED_COLORS: Readonly<{
    aliceblue: "f0f8ff";
    antiquewhite: "faebd7";
    aqua: "0ff";
    aquamarine: "7fffd4";
    azure: "f0ffff";
    beige: "f5f5dc";
    bisque: "ffe4c4";
    black: "000";
    blanchedalmond: "ffebcd";
    blue: "00f";
    blueviolet: "8a2be2";
    brown: "a52a2a";
    burlywood: "deb887";
    burntsienna: "ea7e5d";
    cadetblue: "5f9ea0";
    chartreuse: "7fff00";
    chocolate: "d2691e";
    coral: "ff7f50";
    cornflowerblue: "6495ed";
    cornsilk: "fff8dc";
    crimson: "dc143c";
    cyan: "0ff";
    darkblue: "00008b";
    darkcyan: "008b8b";
    darkgoldenrod: "b8860b";
    darkgray: "a9a9a9";
    darkgreen: "006400";
    darkgrey: "a9a9a9";
    darkkhaki: "bdb76b";
    darkmagenta: "8b008b";
    darkolivegreen: "556b2f";
    darkorange: "ff8c00";
    darkorchid: "9932cc";
    darkred: "8b0000";
    darksalmon: "e9967a";
    darkseagreen: "8fbc8f";
    darkslateblue: "483d8b";
    darkslategray: "2f4f4f";
    darkslategrey: "2f4f4f";
    darkturquoise: "00ced1";
    darkviolet: "9400d3";
    deeppink: "ff1493";
    deepskyblue: "00bfff";
    dimgray: "696969";
    dimgrey: "696969";
    dodgerblue: "1e90ff";
    firebrick: "b22222";
    floralwhite: "fffaf0";
    forestgreen: "228b22";
    fuchsia: "f0f";
    gainsboro: "dcdcdc";
    ghostwhite: "f8f8ff";
    gold: "ffd700";
    goldenrod: "daa520";
    gray: "808080";
    green: "008000";
    greenyellow: "adff2f";
    grey: "808080";
    honeydew: "f0fff0";
    hotpink: "ff69b4";
    indianred: "cd5c5c";
    indigo: "4b0082";
    ivory: "fffff0";
    khaki: "f0e68c";
    lavender: "e6e6fa";
    lavenderblush: "fff0f5";
    lawngreen: "7cfc00";
    lemonchiffon: "fffacd";
    lightblue: "add8e6";
    lightcoral: "f08080";
    lightcyan: "e0ffff";
    lightgoldenrodyellow: "fafad2";
    lightgray: "d3d3d3";
    lightgreen: "90ee90";
    lightgrey: "d3d3d3";
    lightpink: "ffb6c1";
    lightsalmon: "ffa07a";
    lightseagreen: "20b2aa";
    lightskyblue: "87cefa";
    lightslategray: "789";
    lightslategrey: "789";
    lightsteelblue: "b0c4de";
    lightyellow: "ffffe0";
    lime: "0f0";
    limegreen: "32cd32";
    linen: "faf0e6";
    magenta: "f0f";
    maroon: "800000";
    mediumaquamarine: "66cdaa";
    mediumblue: "0000cd";
    mediumorchid: "ba55d3";
    mediumpurple: "9370db";
    mediumseagreen: "3cb371";
    mediumslateblue: "7b68ee";
    mediumspringgreen: "00fa9a";
    mediumturquoise: "48d1cc";
    mediumvioletred: "c71585";
    midnightblue: "191970";
    mintcream: "f5fffa";
    mistyrose: "ffe4e1";
    moccasin: "ffe4b5";
    navajowhite: "ffdead";
    navy: "000080";
    oldlace: "fdf5e6";
    olive: "808000";
    olivedrab: "6b8e23";
    orange: "ffa500";
    orangered: "ff4500";
    orchid: "da70d6";
    palegoldenrod: "eee8aa";
    palegreen: "98fb98";
    paleturquoise: "afeeee";
    palevioletred: "db7093";
    papayawhip: "ffefd5";
    peachpuff: "ffdab9";
    peru: "cd853f";
    pink: "ffc0cb";
    plum: "dda0dd";
    powderblue: "b0e0e6";
    purple: "800080";
    rebeccapurple: "663399";
    red: "f00";
    rosybrown: "bc8f8f";
    royalblue: "4169e1";
    saddlebrown: "8b4513";
    salmon: "fa8072";
    sandybrown: "f4a460";
    seagreen: "2e8b57";
    seashell: "fff5ee";
    sienna: "a0522d";
    silver: "c0c0c0";
    skyblue: "87ceeb";
    slateblue: "6a5acd";
    slategray: "708090";
    slategrey: "708090";
    snow: "fffafa";
    springgreen: "00ff7f";
    steelblue: "4682b4";
    tan: "d2b48c";
    teal: "008080";
    thistle: "d8bfd8";
    tomato: "ff6347";
    turquoise: "40e0d0";
    violet: "ee82ee";
    wheat: "f5deb3";
    white: "fff";
    whitesmoke: "f5f5f5";
    yellow: "ff0";
    yellowgreen: "9acd32";
}>;

/**
 * 在下一渲染帧，仅执行一次传入的方法
 *
 * @param method 需要执行的方法
 * @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数
 */
export declare function nextFrameOnce<T extends (...args: any[]) => any>(method: T, ...args: any[]): undefined;

/**
 * 在下一微任务，仅执行一次传入的方法
 *
 * @param method 需要执行的方法
 * @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数
 */
export declare function nextTickOnce<T extends (...args: any[]) => any>(method: T, ...args: any[]): undefined;

/**
 * 一个空的占位函数
 */
export declare function noop(...args: any[]): any;

/**
 * 将原始透明度值标准化为 0 ~ 1 的值
 *
 * @param a 0 ~ 1，0% ~ 100%
 *
 * @returns 标准化后的透明度
 */
export declare function normalizeAlpha(a: number | string): number;

/**
 * 将原始的 h、s、l 值标准化为 0 ~ 1 的值
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param l 0 ~ 1，0% ~ 100%
 *
 * @returns 标准化后的 HSL 对象
 */
export declare function normalizeHsl(h: number | string, s: number | string, l: number | string): {
    h: number;
    s: number;
    l: number;
};

/**
 * 将原始的 h、s、v 值标准化为 0 ~ 1 的值
 *
 * @param h 0 ~ 360
 * @param s 0 ~ 1，0% ~ 100%
 * @param v 0 ~ 1，0% ~ 100%
 *
 * @returns 标准化的 HSV 对象
 */
export declare function normalizeHsv(h: number | string, s: number | string, v: number | string): {
    h: number;
    s: number;
    v: number;
};

/**
 * 将路径中的 `\` 替换为 `/`
 *
 * @param path 指定的路径
 *
 * @returns 替换后的路径
 */
export declare function normalizePath(path: string): string;

/**
 * 将原始的 r、g、b 值标准化为 0 ~ 1 的值
 *
 * @param r 0 ~ 255
 * @param g 0 ~ 255
 * @param b 0 ~ 255
 *
 * @returns 标准化后 RGB 对象
 */
export declare function normalizeRgb(r: number | string, g: number | string, b: number | string): {
    r: number;
    g: number;
    b: number;
};

export declare const numberRE: RegExp;

export declare type ObjectColor = Exclude<Color, string>;

/**
 * 将给定的数字转换为序数词
 *
 * @param value 需要转换的数字
 *
 * @returns 转换后的序数词
 */
export declare function ordinalNumber(value: number): string;

/**
 * 为给定的整数开头填充 0，直至满足指定的长度
 *
 * @param number 需要处理的整数
 * @param length 填充至的长度
 *
 * @returns 填充后的字面值
 */
export declare function padStartZeros(number: number, length: number): string;

/**
 * 将给定的 {@link Color} 解析为 {@link ColorMeta}
 *
 * @param color 原始颜色值
 *
 * @returns 解析后的颜色元数据
 */
export declare function parseColor(color: Color): ColorMeta;

/**
 * 将给定的 {@link Color} 解析为 {@link RGBAColor}
 *
 * @param originColor 原始颜色值
 *
 * @returns 解析后的 RGB 颜色对象
 */
export declare function parseColorToRgba(originColor: Color): RGBAColor;

/**
 * 将给定的字符串转化为 {@link ObjectColor}，无法转换时返回 null
 *
 * @param color 原始颜色字符串
 *
 * @returns 解析后的颜色对象
 */
export declare function parseStringColor(color: string): ObjectColor | null;

/**
 * 精确的加法
 *
 * @param numbers 需要依次相加的数字
 *
 * @returns 和
 */
export declare const plus: (...numbers: (number | string)[]) => number;

export declare const QUARTER_ON_MONTHS = 3;

/**
 * 检索匹配指定选择器的所有元素
 *
 * @param selector 选择器
 * @param root 根元素，不指定时为 `document.body`
 *
 * @returns 匹配的所有元素
 */
export declare function queryAll(selector: string, root?: Element | null): HTMLElement[];

/**
 * 检索可以被切换焦点（Tab）的元素
 *
 * @param root 根元素，不指定时为 `document.body`
 * @param includeDisabled 是否包含被禁用的元素
 *
 * @returns 可以被切换焦点的元素
 */
export declare function queryTabables(root?: HTMLElement, includeDisabled?: boolean): HTMLElement[];

export declare const raf: (cb: FrameRequestCallback) => void;

/**
 * 在给定的范围内随机一个数
 *
 * @param max 最大值
 * @param min 最小值，默认为 0
 *
 * @returns 生成的随机数
 */
export declare function random(max: number, min?: number): number;

/**
 * 随机生成一个颜色值
 *
 * @param withAlpha 是否具有透明度
 * @param type 颜色的类型
 *
 * @returns 生成的颜色字面值
 */
export declare function randomColor(withAlpha?: boolean, type?: ColorType): string;

/**
 * 随机生成一个冷色调的颜色值
 *
 * @param withAlpha 是否具有透明度
 * @param type 颜色的类型
 *
 * @returns 生成的颜色字面值
 */
export declare function randomHardColor(withAlpha?: boolean, type?: ColorType): string;

/**
 * 随机生成一个特定色调（冷暖色）的颜色值
 *
 * @param prefer 色调
 * @param withAlpha 是否具有透明度
 * @param type 颜色的类型
 *
 * @returns 生成的颜色字面值
 */
export declare function randomPreferColor(prefer: 'hard' | 'soft', withAlpha?: boolean, type?: ColorType): string;

/**
 * 随机生成一个暖色调的颜色值
 *
 * @param withAlpha 是否具有透明度
 * @param type 颜色的类型
 *
 * @returns 生成的颜色字面值
 */
export declare function randomSoftColor(withAlpha?: boolean, type?: ColorType): string;

/**
 * 根据长度生成一串随机的字符串
 *
 * @param length 字符串的长度
 *
 * @returns 生成的字符串
 */
export declare function randomString(length?: number): string;

/**
 * 生成一个值递进的数组
 *
 * @param size 大小
 * @param start 开始的数值，默认为 1
 * @param step 跨度，默认为 1
 *
 * @returns 生成的数组
 */
export declare function range(size: number, start?: number, step?: number): number[];

/**
 * 生成一个天数递进的日期数组
 *
 * @param start 开始日期
 * @param size range 的大小, 默认 42 (一般电子日历为 6 行 7 列)
 * @param step range 的跨幅
 *
 * @returns 生成的日期数组
 */
export declare function rangeDate(start: Dateable, size?: number, step?: number): Date[];

/**
 * 生成一个月份递进的日期数组
 *
 * @param start 开始日期
 * @param size range 的大小, 默认 12 (一年)
 * @param step range 的跨幅
 *
 * @returns 生成的日期数组
 */
export declare function rangeMonth(start: Dateable, size?: number, step?: number): Date[];

declare type RecordKey = string | number | symbol;

/**
 * 移除数组中的某个元素
 *
 * @param array 需要被移除元素的数组
 * @param item 需要被移除的元素, 或一个查找方法，如果元素为函数时则需要做一层简单包装
 * @param isFn 标记数组的元素是否为函数
 *
 * @returns 被移除的元素
 */
export declare function removeArrayItem<T = any>(array: T[], item: T | ((item: T) => boolean), isFn?: boolean): T | null;

declare interface RGB extends Record<any, any> {
    r: number;
    g: number;
    b: number;
    a?: number;
}

export declare const RGB_REG: RegExp;

export declare const RGBA_REG: RegExp;

export declare interface RGBAColor extends RGB {
    a: number;
    format?: 'name' | 'rgba';
}

/**
 * 将 RGBA 颜色转换为 HEX 颜色
 *
 * @param r 0 ~ 255
 * @param g 0 ~ 255
 * @param b 0 ~ 255
 * @param a 0 ~ 1，0% ~ 100%
 * @param allow4Char 是否允许 4 位的 HEX 值
 *
 * @returns 转换后的 HEX 颜色
 */
export declare function rgbaToHex(r: number | string, g: number | string, b: number | string, a: number | string, allow4Char?: boolean): string;

export declare interface RGBColor extends RGB {
    a?: 1;
    format?: 'name' | 'rgb';
}

/**
 * 将 RGB 颜色转换为 HEX 颜色
 *
 * @param r 0 ~ 255
 * @param g 0 ~ 255
 * @param b 0 ~ 255
 * @param allow3Char 是否允许 3 位的 HEX 值
 *
 * @returns 转换后的 HEX 颜色
 */
export declare function rgbToHex(r: number | string, g: number | string, b: number | string, allow3Char?: boolean): string;

/**
 * 将 RGB 颜色转换为 HSL 颜色
 *
 * @param r 0 ~ 255
 * @param g 0 ~ 255
 * @param b 0 ~ 255
 *
 * @returns 转换后的 HSL 颜色
 */
export declare function rgbToHsl(r: number | string, g: number | string, b: number | string): HSLColor;

/**
 * 将 RGB 颜色转换为 HSV 颜色
 *
 * @param r 0 ~ 255
 * @param g 0 ~ 255
 * @param b 0 ~ 255
 *
 * @returns 转换后的 HSV 颜色
 */
export declare function rgbToHsv(r: number | string, g: number | string, b: number | string): HSVColor;

/**
 * 根据临界值对给定的数字进行舍入
 *
 * @param number 需要舍入的数
 * @param criticalValue 舍入的临界值 (0 ~ 1)，达到临界值进位反之舍弃
 *
 * @returns 舍入后的值
 */
export declare function round(number: number, criticalValue: number): number;

/**
 * 按指定的并发数，并行地为系列源数据执行操作
 *
 * @param maxConcurrency 最大的并发数
 * @param source 源数据
 * @param iteratorFn 处理操作的异步函数
 *
 * @returns 等待所有任务执行完的 Promise 对象
 */
export declare function runParallel<T>(maxConcurrency: number, source: T[], iteratorFn: (item: T, source: T[]) => Promise<any>): Promise<any[]>;

/**
 * 将一个任务队列按每帧一次依次指定，返回一个触发取消的方法
 *
 * @param queue 任务队列
 *
 * @returns 终止队列执行的方法
 */
export declare function runQueueFrame(queue: Array<() => void>): () => boolean;

export declare const SECOND_ON_MILLISECONDS = 1000;

/** @deprecated renames to `SECOND_ON_MILLISECONDS` */
export declare const SECOND_ON_MILLS = 1000;

/**
 * 将给定的数字格式化为指定的位阶
 *
 * @param number 需要格式化的数字
 * @param segment 分隔的位数，默认为 3
 * @param separator 分隔的符号，默认为 ','
 *
 * @returns 格式化后的字面值
 */
export declare function segmentNumber(number: number | string, segment?: number, separator?: string): string;

export declare function setGlobalCount(count: number): void;

export declare type SizeUnit = Exclude<SizeUnitWithAuto, AnyCase<'AUTO'>>;

export declare type SizeUnitWithAuto = AnyCase<'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'AUTO'>;

/**
 * 根据依赖的属性对数组逐层排序
 *
 * @param list 需要排序的数组
 * @param props 排序依赖的属性
 *
 * @returns 排序后的数组
 */
export declare function sortByProps<T = any>(list: T[], props: keyof T | SortOptions<keyof T> | (keyof T | SortOptions<keyof T>)[]): T[];

export declare interface SortOptions<T = string> {
    /** 属性名 */
    key: T;
    /** 排序方法 */
    method?: (prev: any, next: any) => number;
    /** 读取方法 */
    accessor?: (...args: any[]) => any;
    /** 升降序 */
    type?: 'asc' | 'desc';
    /** 传入读取器的额外参数 */
    params?: any[];
}

/**
 * 获取给定的日期所在天的开始日期
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function startOfDay(date: Dateable): Date;

/**
 * 获取给定的日期所在小时的开始日期 (分钟归零)
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function startOfHour(date: Dateable): Date;

/**
 * 获取给定的日期所在分钟的开始日期 (秒归零)
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function startOfMinute(date: Dateable): Date;

/**
 * 获取给定的日期所在月份的第一天的开始日期
 *
 * @param date 原始日期
 * @param startOn 设定一个月的第一天，默认为 1 号
 *
 * @returns 新的开始日期
 */
export declare function startOfMonth(date: Dateable, startOn?: number): Date;

/**
 * 获取给定日期所在季度的第一天的开始日期
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function startOfQuarter(date: Dateable): Date;

/**
 * 获取给定的日期所在秒的开始日期（毫秒归零）
 *
 * @param date 原始日期
 *
 * @returns 新的开始日期
 */
export declare function startOfSecond(date: Dateable): Date;

/**
 * 获取给定的日期所在周的第一天的开始日期
 *
 * @param date 需要解析的时间
 * @param startOn 设定周的第一天，默认为周日
 *
 * @returns 新的开始日期
 */
export declare function startOfWeek(date: Dateable, startOn?: number): Date;

/**
 * 获取给定日期所在年份的第一天的开始日期
 *
 * @param date 原始日期
 * @param startOn 设定年的开始月份，默认为一月
 *
 * @returns 新的开始日期
 */
export declare function startOfYear(date: Dateable, startOn?: number): Date;

/**
 * 判断当前的环境是否支持 CSS 样式：`gap`、`row-gap` 和 `column-gap`
 *
 * @returns 是否支持
 */
export declare function supportFlexGap(): boolean;

/**
 * 判断当前环境是否支持 `<img>` 标签的 `loading` 属性
 *
 * @returns 是否支持
 */
export declare function supportImgLoading(): boolean;

/**
 * 将一个方法进行节流
 *
 * @param method 需要节流的方法，需自行绑定 this
 * @param interval 节流后的触发间隔，默认 16 ms (1 帧)
 *
 * @returns 节流后的方法
 */
export declare function throttle<T extends (...args: any[]) => any>(method: T, interval?: number): (...args: Parameters<T>) => void;

/**
 * 精确的乘法
 *
 * @param numbers 需要依次相乘的数字
 *
 * @returns 乘积
 */
export declare const times: (...numbers: (number | string)[]) => number;

/**
 * 将指定的值转换为 HTML 属性值
 *
 * @param value 需要转换的值
 *
 * @returns 转换后的 HTML 属性值
 */
export declare function toAttrValue(value?: boolean | null): 'true' | undefined;

export declare function toAttrValue(value?: string | number | null): string | undefined;

/**
 *  将字面值转换为小驼峰
 *
 * @param value 需要转换的字面值
 *
 * @returns 转换后的小驼峰字面值
 */
export declare function toCamelCase(value: string): string;

/**
 * 将字面值转换为大驼峰
 *
 * @param value 需要转换的字面值
 *
 * @returns 转换后的大驼峰字面值
 */
export declare function toCapitalCase<T extends string>(value: T): CapitalCase<T>;

/**
 * 给定的值如果为合法数字，则将转换为像素值
 *
 * @param value 需要判断的值
 *
 * @returns 转换后的像素值
 */
export declare function toCssSize(value: number | string): string;

/**
 * 将任意可转为 `Date` 对象的变量转为一个新日期
 *
 * @param any 任意可转换的值
 * @param strict 是否在传入非法值时抛错
 *
 * @returns 转换后的 `Date` 对象
 */
export declare function toDate(any: Dateable, strict?: boolean): Date;

/**
 * 一个返回 `false` 的占位函数
 *
 * @returns `false`
 */
export declare function toFalse(...args: any[]): false;

/**
 * 将给定的实数保留一定的小数
 *
 * @param number 需要处理的实数
 * @param decimal 需要保留的小数
 *
 * @returns 保留小数后的值
 */
export declare function toFixed(number: number, decimal: number): number;

/**
 * 获取给定颜色的灰度
 *
 * @param color 颜色字面值
 *
 * @returns 颜色的灰度
 */
export declare function toGrayScale(color: string): number;

/**
 * 将字面值转换为短横线连接
 *
 * @param value 需要转换的字面值
 *
 * @returns 转换后的短横线连接字面值
 *
 * @example
 * ```ts
 * toKebabCase('AaBbCc') // aa-bb-cc
 * toKebabCase('AABb') // aa-bb
 * toKebabCase('AAA') // aaa
 * toKebabCase('AaBb CcDd') // aa-bb cc-dd
 * ```
 */
export declare function toKebabCase(value: string): string;

/**
 * 将给定的值转成数字，NaN 的情况将会处理成 0
 *
 * @param value 需要转换的值
 *
 * @returns 转换后的数字
 */
export declare function toNumber(value: unknown): number;

/**
 * 将数字处理为的指定的有效位数
 *
 * @param number 需要处理的数字
 * @param precision 数字的有效位数
 *
 * @returns 处理后的数字
 *
 * @example
 * ```ts
 * toPrecision(0.09999999999999998) === 0.1 // true
 * ```
 */
export declare function toPrecision(number: number | string, precision?: number): number;

/**
 * 一个返回 `true` 的占位函数
 *
 * @returns `true`
 */
export declare function toTrue(...args: any[]): true;

/**
 * 专用的类型，用于适配 Vexip UI 中 `transfer` 属性的处理
 */
export declare interface TransferNode extends Element {
    __transferElement?: Element | null;
}

/**
 * 将一个展平的列表转换为树
 *
 * @param list 要转换的列表
 * @param options 转换的配置项
 *
 * @returns 转换后的树
 */
declare function transformTree<T = any>(list: T[], options?: TreeOptions<keyof T>): T[];
export { transformTree as buildTree }
export { transformTree }

export declare interface TreeOptions<T = string> {
    keyField?: T;
    childField?: T;
    parentField?: T;
    /** 若指定，`parent` 值等于 `rootId` 的节点被认为是顶级节点 */
    rootId?: any;
}

/**
 * 当前是否可以使用触摸交互
 */
export declare const USE_TOUCH: boolean;

/**
 * 遍历树并为每个节点执行回调方法
 *
 * @param tree 要遍历的树
 * @param cb 回调函数
 * @param options 遍历的配置项
 */
export declare function walkTree<T = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => void, options?: {
    /** 是否为深度优先遍历 */
    depthFirst?: boolean;
    childField?: keyof T;
}): void;

/**
 * 仅发出一次的警告消息
 *
 * @param message 消息内容
 * @param logFn 输出函数
 */
export declare function warnOnce(message: string, logFn?: (...data: any[]) => void): void;

export declare const WEEK_ON_DAYS = 7;

export declare const WEEK_ON_HOURS: number;

export declare const WEEK_ON_MILLISECONDS: number;

/** @deprecated renames to `WEEK_ON_MILLISECONDS` */
export declare const WEEK_ON_MILLS: number;

export declare const WEEK_ON_MINUTES: number;

export declare const WEEK_ON_SECONDS: number;

/**
 * 将指定的文本写入粘贴板
 *
 * @param text 需要写入的文本
 *
 * @returns 是否写入成功
 */
export declare function writeClipboard(text: string): Promise<boolean>;

export declare const YEAR_ON_MONTHS: number;

export declare const YEAR_ON_QUARTERS = 4;

export { }