import { MapOptions, SerializableFunction, ThreadOptions } from '../types';
/**
 * Interface for array operation executor.
 * Allows this module to be used with any ThreadTS-like instance.
 */
export interface ArrayOperationExecutor {
    run<T>(fn: SerializableFunction, data?: unknown, options?: ThreadOptions): Promise<T>;
    map<T, R>(array: T[], fn: SerializableFunction, options?: MapOptions): Promise<R[]>;
}
/**
 * Creates array operation methods bound to a specific executor.
 * This factory pattern allows for dependency injection and testing.
 *
 * @param _executor - The executor instance (ThreadTS or compatible) - reserved for future parallel implementations
 * @returns Object containing all array operation methods
 */
export declare function createArrayOperations(_executor: ArrayOperationExecutor): {
    indexOf: <T>(array: T[], searchElement: T, fromIndex?: number) => Promise<number>;
    lastIndexOf: <T>(array: T[], searchElement: T, fromIndex?: number) => Promise<number>;
    at: <T>(array: T[], index: number) => Promise<T | undefined>;
    slice: <T>(array: T[], start?: number, end?: number) => Promise<T[]>;
    concat: <T>(array: T[], ...items: (T | T[])[]) => Promise<T[]>;
    fill: <T>(array: T[], value: T, start?: number, end?: number) => Promise<T[]>;
    includes: <T>(array: T[], searchElement: T, fromIndex?: number) => Promise<boolean>;
    join: <T>(array: T[], separator?: string) => Promise<string>;
    reverse: <T>(array: T[]) => Promise<T[]>;
    sort: <T>(array: T[], compareFn?: (a: T, b: T) => number) => Promise<T[]>;
    range: (start: number, end: number, step?: number) => Promise<number[]>;
    repeat: <T>(value: T, count: number) => Promise<T[]>;
    zip: <T extends unknown[][]>(...arrays: T) => Promise<{ [K in keyof T]: T[K] extends (infer U)[] ? U : never; }[]>;
    unzip: <T extends unknown[]>(array: T[]) => Promise<{ [K in keyof T]: T[K][]; }>;
    unique: <T>(array: T[]) => Promise<T[]>;
    uniqueBy: <T, K>(array: T[], keyFn: (item: T) => K) => Promise<T[]>;
    flat: <T>(array: T[], depth?: number) => Promise<unknown[]>;
    chunk: <T>(array: T[], size: number) => Promise<T[][]>;
    findLast: <T>(array: T[], predicate: (value: T, index: number, array: T[]) => boolean) => Promise<T | undefined>;
    findLastIndex: <T>(array: T[], predicate: (value: T, index: number, array: T[]) => boolean) => Promise<number>;
    toSorted: <T>(array: T[], compareFn?: (a: T, b: T) => number) => Promise<T[]>;
    toReversed: <T>(array: T[]) => Promise<T[]>;
    withElement: <T>(array: T[], index: number, value: T) => Promise<T[]>;
    toSpliced: <T>(array: T[], start: number, deleteCount?: number, ...items: T[]) => Promise<T[]>;
    groupByObject: <T, K extends PropertyKey>(array: T[], keyFn: (item: T, index: number) => K) => Promise<Partial<Record<K, T[]>>>;
};
/**
 * Type for the array operations object returned by createArrayOperations.
 */
export type ArrayOperations = ReturnType<typeof createArrayOperations>;
//# sourceMappingURL=array-operations.d.ts.map