/**
 * Splits an array into multiple arrays of specified size.
 * @template T
 * @param {T[]} array - The array to split.
 * @param {number} limit - The size limit for each sub-array.
 * @returns {T[][]} An array containing arrays of elements from the original array.
 */
export declare function split<T>(array: T[], limit: number): T[][];
/**
 * Swaps items in an array at specified indices.
 * @param {any[]} array - The array containing the items to swap.
 * @param {number} from - The index of the first item to swap.
 * @param {number} to - The index of the second item to swap.
 * @returns {void}
 */
export declare function swapItems(array: any[], from: number, to: number): void;
/**
 * Shuffles the elements of an array in place.
 * @template T
 * @param {T[]} array - The array to shuffle.
 * @returns {T[]} The shuffled array.
 */
export declare function shuffle<T>(array: T[]): T[];
/**
 * Returns a new array by inserting a specified item between each element of the original array.
 * @template T
 * @param {Readonly<T>[]} array - The array to include the item in.
 * @param {Readonly<T>} item - The item to include between each element.
 * @returns {T[]} A new array with the specified item included between each element.
 */
export declare function include<T>(array: Readonly<T>[], item: Readonly<T>): T[];
/**
 * Checks if two arrays are identical, i.e., have the same elements in the same order.
 * @param {Array} array1 - The first array to compare.
 * @param {Array} array2 - The second array to compare.
 * @returns {boolean} Returns true if the arrays are identical, false otherwise.
 */
export declare function identical(array1: any, array2: any): boolean;
/**
 * Removes the first occurrence of a specified item from an array.
 * @template T
 * @param {T[]} array - The array to remove the item from.
 * @param {T} itemToRemove - The item to remove.
 * @returns {number} The index of the removed item, or -1 if the item is not found.
 */
export declare function remove<T = unknown>(array: T[], itemToRemove: T): number;
/**
 * Finds the index of the first occurrence of a specified element in an array.
 * @template T
 * @param {T[]} items - The array to search for the element.
 * @param {T} element - The element to find.
 * @returns {number} The index of the first occurrence of the element, or -1 if not found.
 */
export declare function findIndex<T = unknown>(items: T[], element: T): number;
/**
 * Finds the intersection of multiple arrays.
 * @param {any[][]} arrays - Arrays to find the intersection from.
 * @returns {any[]} The intersection of the arrays.
 */
export declare function intersection(arrays: any[][]): any[];
/**
 * Removes duplicate elements from an array while preserving the original order.
 * @template T
 * @param {T[]} arr - The array to remove duplicates from.
 * @returns {T[]} A new array with duplicate elements removed.
 */
export declare function removeDuplicates<T>(arr: T[]): T[];