/**
 * Array utility functions for Bench3D
 * Provides helper methods for array manipulation
 */
declare global {
    interface Array<T> {
        safePush(...items: T[]): boolean;
        equals(array: T[]): boolean;
        remove(...items: T[]): void;
        empty(): T[];
        purge(): T[];
        set(index: number, value: T): T[];
        replace(items: T[]): T[];
        allAre(cb: (item: T, index: number) => boolean): boolean;
        findInArray(key: keyof T, value: any): T | false;
        findHighest(callback: (item: T) => number): T | undefined;
        last(): T | undefined;
        findLast(callback: (item: T, index: number) => boolean): T | undefined;
        findLastIndex(callback: (item: T, index: number) => boolean): number | undefined;
        atWrapped(index: number): T;
        positiveItems(): number;
        allEqual(s: T): boolean;
        random(): T | undefined;
        forEachReverse(cb: (item: T, index: number) => void): void;
        overlap(arr2: T[]): number;
        toggle(item: T, state?: boolean): void;
        V3_set(x: number | number[] | any, y?: number, z?: number): number[];
        V3_add(x: number | number[] | any, y?: number, z?: number): number[];
        V3_subtract(x: number | number[] | any, y?: number, z?: number): number[];
        V3_multiply(x: number | number[] | any, y?: number, z?: number): number[];
        V3_divide(x: number | number[] | any, y?: number, z?: number): number[];
        V3_toThree(): any;
        V3_toEuler(): any;
        V2_set(x: number | number[], y?: number): number[];
        V2_add(x: number | number[], y?: number): number[];
        V2_subtract(x: number | number[], y?: number): number[];
        V2_multiply(x: number | number[], y?: number): number[];
        V2_divide(x: number | number[], y?: number): number[];
    }
}
/**
 * Array utility functions
 * Note: These extend Array.prototype, so they're available on all arrays
 */
export declare const ArrayUtil: {
    /**
     * Safely push items to array if they don't already exist
     */
    safePush<T>(arr: T[], ...items: T[]): boolean;
    /**
     * Check if two arrays are equal
     */
    equals<T>(arr1: T[], arr2: T[]): boolean;
    /**
     * Remove items from array
     */
    remove<T>(arr: T[], ...items: T[]): void;
    /**
     * Empty array
     */
    empty<T>(arr: T[]): T[];
    /**
     * Find item in array by key-value
     */
    findInArray<T>(arr: T[], key: keyof T, value: any): T | false;
    /**
     * Find item with highest callback value
     */
    findHighest<T>(arr: T[], callback: (item: T) => number): T | undefined;
    /**
     * Get last item in array
     */
    last<T>(arr: T[]): T | undefined;
    /**
     * Count positive (truthy) items
     */
    positiveItems<T>(arr: T[]): number;
    /**
     * Check if all items equal value
     */
    allEqual<T>(arr: T[], s: T): boolean;
    /**
     * Get random item from array
     */
    random<T>(arr: T[]): T | undefined;
    /**
     * Count overlapping items between two arrays
     */
    overlap<T>(arr1: T[], arr2: T[]): number;
    /**
     * Toggle item in array
     */
    toggle<T>(arr: T[], item: T, state?: boolean): void;
};
//# sourceMappingURL=array_util.d.ts.map