import { ObjectUtilNamespace as O } from '../type';
export declare class ObjectUtil {
    /**
     * 限制值在范围之间
     * @param value
     * @param min
     * @param max
     * @param cycle 值溢出时是否从对向开始计数，如小于最小值时返回最大值
     */
    static toBetween(value: number, min: number, max: number, cycle?: boolean): number;
    /**
     * 立即执行函数表达式（Immediately Invoked Function Expression，简称 IIFE）。
     * 立即执行函数
     * ``` ts
     * // 解决表达式容易和前一行的代码合并的问题，例如以下代码就会报错
     * const arr = []
     * (function() {
     *   // 代码逻辑
     * })();
     * ```
     * @param fn
     */
    static iiFn<T>(fn: {
        (): T;
    }): T;
    /**
     * 立即执行函数
     * 同`iiFn`，无返回值函数
     * @param fn
     */
    static iiFnVoid(fn: {
        (): any;
    }): void;
    /**
     * 复制文本到粘贴板
     * @param text
     */
    static copyToClipboard(text: string): Promise<void>;
    /**
     * 深层循环，可用于代替一部分递归的使用
     * 常见数据处理：
     * 双数组合并成一个children字段
     * ``` ts
     * deepForEach([{ groupList: [], deviceList: [] }], (item, resolve, parent) => {
     *   if (parent) parent.children.unshift(item)
     *   item.children = [...item.deviceList]
     *   if (item.groupList.length) resolve(item.groupList.reverse())
     * })
     * ```
     */
    static deepForEach<T = any, P = T, R = T>(arraySource: T[], callback: O.DeepForEachEachCallback<T, P>): R[];
    /**
     * 前缘防抖 - 立即触发，多次调用触发第一次
     * @param fn
     * @param delay
     */
    static leadingDebounce<T extends any[], R, F extends {
        (...args: T): void;
    }>(fn: F, delay?: number): F;
    /**
     * 延迟
     * @param delay
     */
    static sleep(delay: number): Promise<void>;
    /**
     * 防抖 - 延迟触发,多次调用触发最后一次
     * @param fn
     * @param delay
     */
    static debounce<T extends any[], F extends {
        (...args: T): void;
    }>(fn: F, delay?: number): F;
    /**
     * 节流 - 触发后一段时间内不会再次触发
     * @param fn
     * @param delay
     */
    static throttle<T extends any[], F extends {
        (...args: T): void;
    }>(fn: F, delay?: number): F;
    /**
     * 根据地址获取源数据中的值
     * @param source
     * @param address
     * @param char
     */
    static getAttr<T = unknown>(source: unknown, address: string, char?: string): T | undefined;
    /**
     * 判断参数是否为null|undefined|''
     * @param value
     */
    static isNotEmpty(value: unknown): boolean;
    /**
     * 判断参数是否为null|undefined|''
     * @param value
     */
    static isEmpty(value: unknown): boolean;
    /**
     * 如果value不为空返回value否则返回arg
     * @param value
     * @param arg
     */
    static isEmptyToVal<T, P>(value: T, arg: P): T | P;
    /**
     * 根据source更新target中的属性值
     * @param target
     * @param source
     * @param template
     */
    static updateVal<T extends object>(target: T, source: any, template?: T): void;
    /**
     * 初始化对象数据
     * @param target
     * @param source
     */
    static initClassVal<T>(target: T, source: Partial<T>): void;
    /**
     * 深度克隆 - 不会拷贝函数，能拷贝自引用的对象，无法正确拷贝非JSON的对象如Date
     * 深度：√
     * 自引用：√
     * 非JSON对象：√
     * 函数：Error
     * @param arg
     */
    static copy<T>(arg: T): T;
    /**
     * 将对象转成JSON对象
     * @param arg
     */
    static toJSON<T = any>(arg: T): T;
    /**
     * 合并两个对象
     * @param target
     * @param source
     * @param option
     */
    static assignDeep<T, S>(target: T, source: S, option?: O.AssignDeepOption): T & S;
    /**
     * assignDeep 的递归函数
     * @param target
     * @param source
     * @param option
     * @private
     */
    private static _assignDeep_;
    static isBoolean(arg: unknown): arg is boolean;
    static isString(arg: unknown): arg is string;
    static isNumber(arg: unknown): arg is number;
    static isObject(arg: unknown): arg is Record<string, unknown>;
    static isDate(arg: unknown): arg is Date;
    static isUndefined(arg: unknown): arg is undefined;
}