import { SortOrder, TSortByFn, TGroupTreeBy, TGroupByFn, TArrayOrEmpty } from './types';
/**
 * 插入資料到陣列的第一筆
 *
 * pull([1,2], 3)
 * > [3,1,2]
 *
 * @param arrayData
 * @param pullData
 */
export declare function pull<T, A extends TArrayOrEmpty<T>>(arrayData: A, pullData: T): A;
/**
 * 插入資料到陣列的結尾
 *
 * push([1,2], 3)
 * > [1,2,3]
 *
 * @param arrayData
 * @param pushData
 */
export declare function push<T, A extends TArrayOrEmpty<T>>(arrayData: A, pushData: T): T[];
/**
 * 插入資料到陣列中
 *
 * insert([1,2,3], 1, 4)
 * > [1,4,2,3]
 *
 * @param arrayData
 * @param index
 * @param data
 */
export declare function insert<T, A extends TArrayOrEmpty<T>>(arrayData: A, index: number, data: T): T[];
/**
 * 移動陣列順序
 *
 * move([A, B, C], 1, 2)
 * > [A, C, B]
 *
 * @param arrayData
 * @param index
 * @param toIndex
 */
export declare function move<T, A extends TArrayOrEmpty<T>>(arrayData: A, index: number, toIndex: number): A;
/**
 * 依賴 findIndex 後 removeByIndex
 *
 * removeFind([1,2,3], (item) => item === 2)
 * > [1,3]
 *
 * @param arrayData
 * @param fn
 */
export declare function removeFind<T, A extends TArrayOrEmpty<T>>(arrayData: T[] | A, fn: (item: T) => boolean): A;
/**
 * 依賴 findIndex 後 updateByIndex
 *
 * updateFind([
 *    {id: 1, text: 'a'},
 *    {id: 2, text: 'b'},
 * ],{
 *   finder: (item) => item.id === 2,
 *   updater: (item) => { item.text = 'X'; }
 * }
 * )
 * > [
 *    {id: 1, text: 'a'},
 *    {id: 2, text: 'X'},
 *   ]
 *
 * @param arrayData
 * @param args
 */
export declare function updateFind<T, A extends TArrayOrEmpty<T>>(arrayData: T[] | A, args: {
    finder: (item: T) => boolean;
    updater: (item: T) => void;
}): A;
/**
 * 刪除陣列中的一筆資料
 *
 * removeByIndex([1,2,3], 1)
 * > [1,3]
 *
 * @param arrayData
 * @param index
 */
export declare function removeByIndex<T, A extends TArrayOrEmpty<T>>(arrayData: T[] | A, index: number): A;
/**
 * 更改陣列中的一筆資料
 *
 * updateByIndex([{name: 'jack'}], 0, {name: 'imagine'})
 * > [{name: 'imagine'}]
 *
 * @param arrayData
 * @param index
 * @param updateFn
 */
export declare function updateByIndex<T, A extends TArrayOrEmpty<T>>(arrayData: T[] | A, index: number, updateFn: (item: T) => void): A;
/**
 * 取得陣列中的唯一值
 *
 * unique(['a', 'a', 'c'])
 * > ['a', 'c']
 *
 * @param data
 * @param selector
 */
export declare function unique<T>(data: T[], selector?: (item: T) => any): T[];
/**
 * 陣列轉字串 (發生例外錯誤回傳 空陣列)
 *
 * arrayJoin(['a', 'b'], ',')
 * > 'a,b'
 *
 * @param arrayData
 * @param separator
 */
export declare function arrayJoin(arrayData: TArrayOrEmpty<string>, separator: string): string;
/**
 * 取得陣列第一筆資料
 * arraySplit(['a','b','c']);
 * > a
 */
export declare function arrayFirst<T = undefined>(array?: T[]): T | undefined;
/**
 * 分割陣列
 *
 * arraySplit([1,2,3,4,5], 2)
 * > [[1,2], [3,4], [5]]
 *
 * @param arrayData
 * @param splitCount
 */
export declare function arraySplit<T, A extends TArrayOrEmpty<T>>(arrayData: A, splitCount: number): A | T[][];
/**
 * GroupBy
 *
 * groupBy([{name: 'a', age: 1}, {name: 'b', age: 2}], (item) => item.age)
 * > {1: [{name: 'a', age: 1}], 2: [{name: 'b', age: 2}]}
 *
 * @param array
 * @param fn
 */
export declare function groupBy<T>(array: T[], fn: TGroupByFn<T>): Record<string | number, T[]>;
/**
 * Group TreeBy
 *
 * groupTreeBy([{name: 'a', age: 1}, {name: 'b', age: 2}], (item) => {
 *    return {
 *      groupKey: item.age,
 *      groupData: {age: item.age},
 *      child: item
 *    }
 * })
 * > [{age: 1, children: [{name: 'a', age: 1}]}, {age: 2, children: [{name: 'b', age: 2}]}]
 *
 *
 * @param array
 * @param groupByFn
 */
export declare function groupTreeBy<T, D, C>(array: T[], groupByFn: TGroupTreeBy<T, D, C>): Array<D & {
    children: C[];
}>;
/**
 * Sort
 *
 * sort([3,2,1], (a, b) => a - b)
 * > [1,2,3]
 *
 * @param array
 * @param fn
 */
export declare function sort<T>(array: T[], fn: TSortByFn<T>): T[];
/**
 * 生成排序方法
 * @param selector
 * @param order
 */
export declare function generateSortByProperty<T>(selector: (row: T) => any, order?: SortOrder): (a: T, b: T) => number;
/**
 * 生成 Array 數量
 * @param count 生成多少個
 * @param prefixKeyName 前綴 Key name
 */
export declare const generatorArray: (count: number, prefixKeyName?: string) => string[];
/**
 * 循環切換
 * const toggle = generatorArrayToggle(['a','b','c']);
 * toggle(a)
 * > b
 * toggle(b)
 * > c
 * toggle(c)
 * > a
 */
export declare function generatorArrayToggle<T>(data: T[]): (current: T) => T;