export declare namespace ArrayTools {
    /**
     *
     * @param array
     * @returns shuffled copy of array
     * @deprecated use new Random().Shuffle() instead
     */
    function Shuffle<T extends defined>(array: readonly T[]): T[];
    /**removes the element from the array */
    function RemoveElementFromArray<T extends defined>(array: T[], element: T): T | undefined;
    /**removes all or 1 elements if they check function returns true
     * @param [stop_on_first=true]
     * @returns removed elements
     */
    function RemoveFromArray<T extends defined>(array: T[], check: (element: T) => boolean, stop_on_first?: boolean): T[];
    function IncludesOneOf<T extends defined>(array: readonly T[], possible_elements: T[]): boolean;
    /**@returns same elements in the arrays */
    function GetIntersection<T extends defined>(array_0: readonly T[], array_1: readonly T[]): T[];
    /**if insert_check returns true, element will be inserted at index of value that it's getting compared to
     * @param a - inserted value
     * @param b - other value
     */
    function SortedInsert<T extends defined>(array: T[], value: T, insert_check: (current_value: T, b: T, index: number, array: T[]) => boolean): void;
    /**
     * interts elements at position
     * @param array
     * @param elements
     * @param position
     */
    function InsertElements<T extends defined>(array: Array<T>, elements: Array<T>, position?: number): T[];
    /**pushes element to the array if it doesnt exist */
    function PushIfDoesntExist<T extends defined>(array: Array<T>, element: T): void;
    /**
     * @param arrays
     * @returns array that contains all elements from arrays
     */
    function JoinArrays<T extends defined>(arrays: readonly T[][]): T[];
    function GetRandomElement<T>(array: readonly T[]): T;
    type WeigtedArray<T extends defined> = Array<[number, T]>;
    function WeightedPick<T extends defined>(array: WeigtedArray<T>): T;
    /**filters the same value, if selector is undefined will use the element itself to compare
     * overrides array and retuns it
     */
    function FilterSame<T extends defined, Q extends defined>(array: Array<T>, selector?: (element: T) => Q): T[];
    /**
     *
     * @param array
     * @param start
     * @param finish
     * @returns cut copy of array
     */
    function SubArray<T extends defined>(array: readonly T[], start: number, finish: number): T[];
    /**
     * compares 2 array, returns true if they have same elements
     */
    function Compare<T extends defined>(array_0: readonly T[], array_1: readonly T[], selector?: <Q extends defined>(array: readonly T[]) => Q): boolean;
    /**
     * loops in the opposite direction
     * equivalent to for(let i = array.size() - 1; i >= 0, i--)
     */
    function ReverseLoop<T extends defined>(array: readonly T[], callback: (value: T, index: number, array: readonly T[]) => void): void;
    /**swaps elements in the table by indexes */
    function SwapIndexes<T extends defined>(array: T[], index_0: number, index_1: number): void;
    /**
     * @param array
     * @returns reversed copy of array
     */
    function Reverse<T extends defined>(array: readonly T[]): T[];
    /**
     * indexes the array and wraps the index
     * equivalent to array[index % array.size()]
     */
    function WrapIndex<T>(array: readonly T[], index: number): T;
    /**
     * makes binary search in sorted array
     * @param array
     * @param element
     * @param return_min if didnt find the element and this is true, will return the index of the closes smallest element
     * @returns index of the element, -1 if didnt find the element
     */
    function BinarySearch(array: readonly number[], element: number, return_min?: boolean): number;
    /**
     * makes binary search in sorted array
     * @param array
     * @param element
     * @param return_min if didnt find the element and this is true, will return the index of the closes smallest element
     * @returns index of the element, -1 if didnt find the element
     */
    function BinarySearchObject<T>(array: readonly T[], element: number, selector: (element: T) => number, return_min?: boolean): number;
    function CountElement<T extends defined, Q>(array: readonly T[], search_element: Q, selector?: (item: T) => Q): number;
    /**
     * splits array on arrays with fixed amount of components or less
     * @param array
     * @param amount_per_table
     * @returns
     */
    function SplitArray<T extends defined>(array: readonly T[], amount_per_table: number): (readonly T[])[];
    /**
     * converts array to map
     * @param array array of elements to convert to the map
     * @param selector returns [key, value] for map
     * @returns map<key, value>
     */
    function ToMap<T extends defined, K, V>(array: readonly T[], selector: (value: T, index: number, array: readonly T[]) => [key: K, value: V]): Map<K, V>;
}