index.d.ts

export declare type DeepReadonly<T> = T extends (infer R)[] ? DeepReadonlyArray<R> : T extends Function ? T : T extends object ? DeepReadonlyObject<T> : T;
export interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
}
export declare type DeepReadonlyObject<T> = {
    readonly [P in keyof T]: DeepReadonly<T[P]>;
};
export declare function delay(timeSecond: number): Promise<void>;
export declare function deepCopy<T>(obj: T): T;
export declare function deepFreeze<T>(obj: T): DeepReadonly<T>;
export declare function shallowEqual(objA: any, objB: any): boolean;
export declare function deepEqual(x: any, y: any): boolean;
/**
   * @param  [wait] -          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
   * @param  [noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the
   *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time
   *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,
   *                                    the internal counter is reset).
    */
export declare function throttle<T extends Function>(func: T, wait?: number, immediate?: boolean, noTrailing?: boolean): T & {
    clear: () => void;
};
export declare function debounce<T extends Function>(func: T, wait?: number, immediate?: boolean): T & {
    clear: () => void;
    flush: () => void;
};
export declare function uniqArray<T>(array: T[]): T[];
export declare function assign(object: any, obj2: any): any;
export declare function assignM(object: any, ...objs: any[]): any;
export declare function md5(str: string): string;