export declare class ArrayUtils {
    /**
     * Returns whether at least one element in given array could be found by given finder function.
     *
     * @param {T[]} array
     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents
     * the 'found status' for that element; whether it should have been found or not.
     */
    static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean;
    /**
     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
     * undefined when none was found.
     *
     * Example usage:
     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
     *     (return modelItem.getId() === '1')
     *   * });
     *
     * @param array The array with items to search in.
     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
     */
    static Find<T>(array: T[], foundBy: (item: T) => boolean): T;
    static FindAll<T>(array: T[], foundBy: (item: T) => boolean): T[];
    static CloneArray<T>(array: T[]): T[];
    /**
     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),
     * or just as plain object (see param arrayItemsClass).
     * @param array
     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
     * it'll be a plain object.
     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..
     * @returns {Array} semi-deep clone of given array
     */
    static CloneArrayAndItsItems<T>(array: T[], arrayItemsClass?: any, deepClone?: boolean): T[];
    /**
     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
     * removes the element using splice().
     *
     * @param {number} index
     * @param {any[]} array in-out
     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.
     */
    static RemoveElementAtIndex(index: number, array: any[]): boolean;
    /**
     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the
     * element using splice(). Also works on associative arrays.
     *
     * @param {T} element The element to remove.
     * @param {T[]} array The array to remove the element from.
     * @returns {boolean} True iff given element was truly successfully removed from given array.
     */
    static RemoveElement<T>(element: T, array: T[]): boolean;
    static IsArrayWithElements<T>(arrayToCheck: T[], classItemsMustBeInstanceOf?: any): boolean;
    static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean;
    static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean;
    static PlaceElementAfterOther(array: any[], elementToPlace: any, afterThisElement: any): void;
    /**
     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
     * @param array
     * @param itemValueFunction The function applied to each array item that gives it a numerical value. The max num val found is returned.
     */
    static GetMaxCalculatedValue<T>(array: T[], itemValueFunction: (item: T) => number): number;
}
