import { ArrayUtilNamespace as T } from '../type';
export declare class ArrayUtil {
    /**
     * reduce函数的简化使用，默认返回previousValue数据
     * @param array
     * @param callbackFn
     * @param initialValue
     */
    static reduce<T, R>(array: T[], callbackFn: T.ReduceCallbackFn<T, R>, initialValue: R): R;
    /**
     * 将数据根据字段分组
     * ``` typescript
     * const data = [
     *  { label: 'A', age: 11 },
     *  { label: 'B', age: 22 },
     *  { label: 'C', age: 13 },
     *  { label: 'A', age: 24 },
     * ]
     * const result = ArrayUtil.groupByField(data, 'label')
     * // result 结果
     * {
     *  A: [{ label: 'A', age: 11 }, { label: 'A', age: 24 }],
     *  B: [{ label: 'B', age: 22 }],
     *  C: [{ label: 'C', age: 13 }]
     * }
     * ```
     * @param array 需要迭代的数据
     * @param field 字段名
     * @return Record<string, T[]>
     */
    static groupByField<T extends Record<string, any>, K extends {
        [P in keyof T]: T[P] extends (string | number) ? P : never;
    }[keyof T]>(array: T[], field: K): Record<string, T[]>;
    /**
     * 为数组创建字典，方便查找数组中的数据
     * @param array 需要迭代的数据
     * @param field 字段名，一般为唯一标识如id、key等
     * @return Record<string, T>
     */
    static createStrDic<T extends Record<string, any>, K extends {
        [P in keyof T]: T[P] extends (string | number) ? P : never;
    }[keyof T]>(array: T[], field: K): Record<string, T>;
    /**
     * 为数组创建字典，方便查找数组中的数据
     * @param array 需要迭代的数据
     * @param field 字段名，一般为唯一标识如id、key等
     * @return Map<unknown, T>
     */
    static createMapDic<T extends Record<string, any>, K extends keyof T>(array: T[], field: K): Map<unknown, T>;
    /**
     * 获取对象数组中指定字段的所有数据，返回一个对象包含这些数据
     * ``` typescript
     * const data = [
     *  { value: 1, label: '张三' },
     *  { value: 2, label: '李四' },
     *  { value: 3, label: '王五' },
     * ]
     * const result = ArrayUtil.valuesByFields(data, ['value', 'label'])
     * // result 结果
     * {
     *  value: [1, 2, 3],
     *  label: ['张三', '李四', '王五‘]
     * }
     * ```
     * @param data
     * @param fields
     */
    static valuesByFields<T extends Record<string, any>, F extends keyof T>(data: T[], fields: F[]): {
        [K in F]: T[K][];
    };
    /**
     * 获取对象数组中指定字段的所有数据，返回一个数组
     * ``` typescript
     * const data = [
     *  { value: 1, label: '张三' },
     *  { value: 2, label: '李四' },
     *  { value: 3, label: '王五' },
     * ]
     * const result = ArrayUtil.valuesByFields(data, 'value')
     * // result 结果
     * [1, 2, 3]
     * ```
     * @param data
     * @param field
     */
    static valuesByField<T extends Record<string, any>, F extends keyof T>(data: T[], field: F): T[F][];
}