export declare const arrays: {
    /**
     * Ensures the given parameter is an array.
     */
    ensure<T>(array: T | T[]): T[];
    /**
     * Creates an array with the given length and initializes each value with the given initValue.
     */
    init<T_1>(length: number, initValue: T_1): T_1[];
    /**
     * Removes the first occurrence of the specified element from the array.
     * If the array does not contain the element, it stays unchanged.
     *
     * @returns true if an element was removed
     */
    remove<T_2>(arr: T_2[], element: T_2): boolean;
    /**
     * Removes the first array element that matches the given predicate.
     * If no element matches the given predicate, the array stays unchanged.
     *
     * @returns true if an element was removed
     */
    removeByPredicate<T_3>(arr: T_3[], predicate: (elem: T_3, index: number, arr: T_3[]) => boolean, thisArg?: any): boolean;
    /**
     * Removes every given element from the array
     *
     * @returns true if the array contained at least one of the specified elements
     */
    removeAll<T_4>(arr: T_4[], elements: T_4[]): boolean;
    /**
     * @returns the index of the replaced element
     */
    replace<T_5>(arr: T_5[], element: T_5, replacement: T_5): number;
    /**
     * Inserts the given element at the specified index.
     * <p>
     * This function uses {@link insertAll} which relies on Array.prototype.splice(). Check its js-doc for details.
     */
    insert<T_6>(arr: T_6[], element: T_6, index: number): void;
    /**
     * Inserts all elements of the given array at the specified index.
     *
     * This function is based on Array.prototype.splice().
     * Thus, if the 'index' is greater than the length of the array, 'elements' will be added to the end of the array 'arr'.
     * This may cause unexpected behavior on accessing arr[index] after insertion.
     *
     * The caller must ensure the size of the array.
     */
    insertAll<T_7>(arr: T_7[], elements: T_7 | T_7[], index: number): void;
    /**
     * Inserts the given element into the array according to the sort order indicated by the given comparison function.
     *
     * All arguments are mandatory.
     */
    insertSorted<T_8>(arr: T_8[], element: T_8, compareFunc: (a: T_8, b: T_8) => number): void;
    /**
     * Inserts to given element into the array directly BEFORE the first array element that matches the given predicate.
     * If no such element can be found, the new element is inserted at the BEGINNING of the array.
     *
     * @param thisArg optional "this" binding for predicate function
     */
    insertBefore<T_9>(arr: T_9[], elementToInsert: T_9, predicate: (elem: T_9, index: number, arr: T_9[]) => boolean, thisArg?: any): void;
    /**
     * Inserts to given element into the array directly AFTER the first array element that matches the given predicate.
     * If no such element can be found, the new element is inserted at the END of the array.
     */
    insertAfter<T_10>(arr: T_10[], elementToInsert: T_10, predicate: (elem: T_10, index: number, arr: T_10[]) => boolean): void;
    /**
     * Moves the element at fromIndex to toIndex.
     *
     * This function uses {@link insert} which relies on Array.prototype.splice(). Check its js-doc for details.
     */
    move<T_11>(arr: T_11[], fromIndex: number, toIndex: number): void;
    /**
     * Moves the given element before the sibling and returns the array with the new order.
     */
    moveBefore<T_12>(arr: T_12[], elementToMove: T_12, sibling: T_12): T_12[];
    /**
     * Moves the given element after the sibling and returns the array with the new order.
     */
    moveAfter<T_13>(arr: T_13[], elementToMove: T_13, sibling: T_13): T_13[];
    /**
     * Moves the given element to the position returns the array with the new order.
     */
    moveTo<T_14>(arr: T_14[], elementToMove: T_14, position: number): T_14[];
    contains<T_15>(haystack: T_15[], needle: T_15): boolean;
    containsAny<T_16>(haystack: T_16 | T_16[], needles: T_16 | T_16[]): boolean;
    containsAll<T_17>(haystack: T_17 | T_17[], needles: T_17 | T_17[]): boolean;
    first<T_18>(arr: T_18[]): T_18;
    last<T_19>(arr: T_19[]): T_19;
    /**
     * @returns true if the given argument is an array and has a length > 0, false in any other case.
     */
    hasElements<T_20>(arr: T_20 | T_20[]): boolean;
    /**
     * @returns true if the given argument is not an array or the length of the array is 0, false in any other case.
     */
    empty<T_21>(arr: T_21 | T_21[]): boolean;
    /**
     * @returns the size of the array, or 0 if the argument is not an array
     */
    length<T_22>(arr: T_22 | T_22[]): number;
    pushAll<T_23>(arr: T_23[], arr2: T_23 | T_23[]): void;
    /**
     * Merges the two given arrays and removes duplicate entries in O(n).
     * If the arrays contain objects instead of primitives, it uses their id to check for equality.
     */
    union<T_24 extends string | number | {
        id: string;
    }>(array1: T_24[], array2: T_24[]): T_24[];
    equalsIgnoreOrder(arr: any[], arr2: any[]): boolean;
    equals(arr: ArrayLike<any>, arr2: ArrayLike<any>): boolean;
    greater(arr: [], arr2: []): boolean;
    eachSibling<T_25>(arr: ArrayLike<T_25>, element: T_25, func: (elem: T_25, index: number) => void): void;
    /**
     * Alternative implementation of Array.findIndex(callback [, thisArg]), which is supported by most browsers.
     * See Array.findIndex for a detailed description.
     *
     * @param optional "this" binding for predicate function
     */
    findIndex<T_26>(arr: ArrayLike<T_26>, predicate: (elem: T_26, index: number, arr: T_26[]) => boolean, thisArg?: any): number;
    /**
     *
     * @param thisArg optional "this" binding for predicate function
     */
    find<T_27>(arr: ArrayLike<T_27>, predicate: (elem: T_27, index: number, arr: T_27[]) => boolean, thisArg?: any): T_27;
    findFrom<T_28>(arr: ArrayLike<T_28>, startIndex: number, predicate: (elem: T_28, index: number) => boolean, reverse?: boolean): T_28;
    findIndexFrom<T_29>(arr: ArrayLike<T_29>, startIndex: number, predicate: (elem: T_29, index: number) => boolean, reverse?: boolean): number;
    findFromForward<T_30>(arr: ArrayLike<T_30>, startIndex: number, predicate: (elem: T_30, index: number) => boolean): T_30;
    findIndexFromForward<T_31>(arr: ArrayLike<T_31>, startIndex: number, predicate: (elem: T_31, index: number) => boolean): number;
    findFromReverse<T_32>(arr: ArrayLike<T_32>, startIndex: number, predicate: (elem: T_32, index: number) => boolean): T_32;
    findIndexFromReverse<T_33>(arr: ArrayLike<T_33>, startIndex: number, predicate: (elem: T_33, index: number) => boolean): number;
    /**
     * Pushes all elements to the given array that are not null or undefined.
     */
    pushIfDefined<T_34>(arr: T_34[], ...elements: T_34[]): void;
    /**
     * Pushes the given element if it does not already exist in the array and the element is truthy. Thus, the array is like a Set where every element
     * can only be added once to the collection. Note: the comparison is done with the === operator.
     */
    pushSet<T_35>(arr: T_35[], element: T_35): void;
    /**
     * Creates a string containing all elements in the array separated by the given delimiter.
     * @param encodeHtml true to encode the elements, false if not. Default is false
     */
    format(arr: ArrayLike<string>, delimiter?: string, encodeHtml?: boolean): string;
    formatEncoded(arr: ArrayLike<string>, delimiter?: string): string;
    max(arr: number[]): number;
    min(arr: number[]): number;
    /**
     * @returns all elements of the first array which are not in the second array
     */
    diff<T_36>(arr1: T_36[], arr2: T_36[]): T_36[];
    flatMap<T_37, R>(arr: T_37 | T_37[], func?: (T: any) => R | R[]): R[];
    /**
     * Returns a flat array of all elements and their recursive child elements.
     *
     * @param arr The top-level list of all elements
     * @param childrenAccessor Function than extracts a list of child elements from a given element. Used to traverse the object structure.
     */
    flattenRec<T_38>(arr: T_38[], childrenAccessor: (T: any) => T_38[]): T_38[];
    /**
     * Replacement for indexOf() that works for arrays of jQuery objects (compares DOM nodes).
     */
    $indexOf(arr: JQuery[], $element: JQuery): number;
    /**
     * Replacement for remove() that works for arrays of jQuery objects (compares DOM nodes).
     */
    $remove(arr: JQuery[], $element: JQuery): void;
    randomElement<T_39>(array: T_39[]): T_39;
    /**
     * Converts the given array to a map. For each element, key and value is determined by the given functions.
     * If no function is provided, the element itself is used.
     *
     * @param array array of elements
     * @param keyMapper function that maps each element to the target key
     * @param valueExtractor function that maps each element to the target value
     */
    toMap<T_40>(array: T_40[], keyMapper?: (el: T_40) => PropertyKey, valueMapper?: (el: T_40) => any): any;
    /**
     * If the argument is an empty array, null is returned. Otherwise, the argument is returned unchanged.
     */
    nullIfEmpty<T_41>(array: T_41[]): T_41[];
    /**
     * Clears the content of an array <i>in-place</i>. All elements are removed from the array and the
     * length will be set to 0. If the given argument is not an array, nothing happens.
     *
     * This is a more readable version of `array.splice(0, a.length)`.
     *
     * The return value is an array of all deleted elements (never null).
     */
    clear<T_42>(array: T_42[]): T_42[];
    /**
     * Swaps the two elements in the array.
     * Does nothing if array is null or undefined or one of the element is not part of the array.
     */
    swap<T_43>(array: T_43[], element1: T_43, element2: T_43): void;
};
//# sourceMappingURL=arrays.d.ts.map