@antv/util

assign: <Base, A, B, C>(
    dist: Base & A & B & C,
    src1?: A,
    src2?: B,
    src3?: C
) => Base & A & B & C;

augment: (...args: any[]) => void;

clamp: (a: number, min: number, max: number) => number;

clearAnimationFrame: (handler: number) => void;

clone: (obj: any) => any;

contains: (arr: any[], value: any) => boolean;

debounce: (func: Function, wait?: number, immediate?: boolean) => () => void;

deepMix: (rst: any, ...args: any[]) => any;

difference: <T>(arr: T[], values?: T[]) => T[];

each: (elements: any[] | object, func: (v: any, k: any) => any) => void;

endsWith: { (arr: string, e: string): boolean; <T>(arr: T[], e: T): boolean };

every: <T>(arr: T[], func: (v: T, idx?: number) => any) => boolean;

extend: (
    subclass: any,
    superclass: any,
    overrides?: any,
    staticOverrides?: any
) => any;

filter: <T>(arr: T[], func: (v: T, idx: number) => boolean) => T[];

find: {
    <T>(arr: T[], predicate: Function): T;
    <T>(arr: T[], predicate: object): T;
};

findIndex: <T>(
    arr: T[],
    predicate: (item: T, idx?: number) => boolean,
    fromIndex?: number
) => number;

firstValue: (data: object[], name: string) => any;

fixedBase: (v: number, base: number | string) => number;

flatten: <T>(arr: T[]) => T[];

flattenDeep: (arr: any[], result?: any[]) => any[];

forIn: (elements: any[] | object, func: (v: any, k: any) => any) => void;

get: (obj: any, key: string | any[], defaultValue?: any) => any;

getRange: (values: number[]) => RangeType;

getType: (value: any) => string;

getWrapBehavior: (obj: object, action: string) => Function;

group: <T>(
    data: T[],
    condition: string | string[] | ((v: T) => string)
) => T[][];

groupBy: {
    <T>(data: T[], condition: (item: T) => string): ObjectType<T>;
    <T>(data: T[], condition: string): ObjectType<T>;
};

groupToMap: (
    data: any,
    condition: string | string[] | ((row: any) => string)
) => import('./group-by').ObjectType<any> | { 0: any };

has: (obj: object, key: any) => boolean;

hasKey: (obj: object, key: any) => boolean;

hasValue: (obj: object, value: any) => boolean;

head: (o: unknown) => any;

identity: <T>(v: T) => T;

includes: (arr: any[], value: any) => boolean;

indexOf: <T>(arr: T[], obj: T) => number;

isArguments: (value: any) => boolean;

isArray: (value: any) => value is any[];

isArrayLike: (value: any) => boolean;

isBoolean: (value: any) => value is boolean;

isDate: (value: any) => value is Date;

isDecimal: (num: any) => boolean;

isElement: (o: any) => boolean;

isEmpty: (value: any) => boolean;

isEqual: (value: any, other: any) => boolean;

isEqualWith: <T>(value: T, other: T, fn: (v1: T, v2: T) => boolean) => boolean;

isError: (value: any) => value is Error;

isEven: (num: any) => boolean;

isFinite: (value: any) => value is number;

isFunction: (value: any) => value is Function;

isInteger: (number: unknown) => boolean;

isMatch: (obj: any, attrs: any) => boolean;

isNegative: (num: any) => boolean;

isNil: (value: any) => value is null;

isNull: (value: any) => value is null;

isNumber: (value: any) => value is number;

isNumberEqual: (a: number, b: number, precision?: number) => boolean;

isObject: <T = object>(value: any) => value is T;

isObjectLike: (value: any) => value is object;

isOdd: (num: any) => boolean;

isPlainObject: (value: any) => value is object;

isPositive: (num: any) => boolean;

isPrototype: (value: any) => boolean;

isRegExp: (str: any) => str is RegExp;

isString: (str: any) => str is string;

isType: (value: any, type: string) => boolean;

isUndefined: (value: any) => value is undefined;

keys: (obj: any) => any[];

last: (o: unknown) => any;

lowerCase: (str: string) => string;

lowerFirst: (value: string) => string;

map: <T, G>(arr: T[], func: (v: T, idx: number) => G) => G[];

mapValues: <T>(
    object: { [key: string]: T },
    func?: (value: T, key: string) => any
) => { [key: string]: any };

max: (arr: number[]) => number | undefined;

maxBy: <T>(arr: T[], fn: string | ((v: T) => number)) => T;

memoize: (
    f: Function,
    resolver?: (...args: any[]) => string
) => { (...args: any[]): any; cache: any };

min: (arr: number[]) => number | undefined;

minBy: <T>(arr: T[], fn: string | ((v: T) => number)) => T;

mix: <Base, A, B, C>(
    dist: Base & A & B & C,
    src1?: A,
    src2?: B,
    src3?: C
) => Base & A & B & C;

mod: (n: number, m: number) => number;

noop: () => void;

number2color: (num: number) => string;

omit: <T>(obj: ObjectType<T>, keys: string[]) => ObjectType<T>;

parseRadius: { (radius: number): RadiusType; (radius: number[]): RadiusType };

pick: <T>(object: ObjectType<T>, keys: string[]) => ObjectType<T>;

pull: <T>(arr: T[], ...values: any[]) => T[];

pullAt: <T>(arr: T[], indexes: number[]) => T[];

reduce: <T, G>(
    arr: ObjectType<T> | G[],
    fn: (result: T, data: G, idx: string | number) => T,
    init: T
) => T;

remove: <T>(
    arr: T[],
    predicate: (value: T, idx: number, arr?: T[]) => boolean
) => T[];

requestAnimationFrame: (fn: any) => any;

set: (obj: any, path: string | any[], value: any) => any;

size: (o: unknown) => number;

some: <T>(arr: T[], func: (v: T, idx?: number) => any) => boolean;

sortBy: {
    <T>(arr: ObjectType<T>[], key: Function): ObjectType<T>[];
    <T>(arr: ObjectType<T>[], key: string): ObjectType<T>[];
    <T>(arr: ObjectType<T>[], key: string[]): ObjectType<T>[];
};

startsWith: { (arr: string, e: string): boolean; <T>(arr: T[], e: T): boolean };

substitute: <T>(str: string, o: ObjectType<T>) => string;

throttle: (func: Function, wait: number, options: OptionsType) => Function;

toArray: (value: any) => any[];

toDegree: (radian: number) => number;

toInteger: (s: string, radix?: number) => number;

toRadian: (degree: number) => number;

toString: (value: any) => string;

union: (...sources: any[]) => any[];

uniq: (arr: any[], cache?: any) => any[];

uniqueId: (prefix?: string) => string;

upperCase: (str: string) => string;

upperFirst: (value: string) => string;

values: (obj: any) => any;

valuesOfKey: (data: any[], name: string) => any[];

wrapBehavior: (obj: object, action: string) => Function;