import { EventEmitter } from 'node:events';

/**
 * @akson/cortex-utilities - Bulk Operations Manager
 * Intelligent batch processing with concurrency control and error recovery
 */

interface BulkOptions {
    /** Maximum items to process in a single batch */
    batchSize?: number;
    /** Maximum concurrent batches to process */
    concurrency?: number;
    /** Whether to retry failed items */
    retryFailedItems?: boolean;
    /** Maximum number of retries per item */
    maxRetries?: number;
    /** Delay between retries in milliseconds */
    retryDelay?: number;
    /** Exponential backoff factor for retries */
    retryBackoffFactor?: number;
    /** Continue processing on error or stop */
    onError?: "continue" | "stop";
    /** Progress callback */
    onProgress?: (progress: BulkProgress) => void;
    /** Item completion callback */
    onItemComplete?: (item: any, result: any, index: number) => void;
    /** Item error callback */
    onItemError?: (item: any, error: Error, index: number) => void;
    /** Batch completion callback */
    onBatchComplete?: (batchIndex: number, results: any[]) => void;
    /** Whether to validate items before processing */
    validateBeforeProcess?: boolean;
    /** Custom validation function */
    validator?: (item: any) => boolean | Promise<boolean>;
    /** Whether to collect detailed metrics */
    collectMetrics?: boolean;
}
interface BulkProgress {
    /** Total number of items to process */
    total: number;
    /** Number of successfully processed items */
    processed: number;
    /** Number of failed items */
    failed: number;
    /** Number of skipped items (validation failed) */
    skipped: number;
    /** Current processing percentage */
    percentage: number;
    /** Estimated time remaining in milliseconds */
    estimatedTimeRemaining?: number;
    /** Current batch being processed */
    currentBatch?: number;
    /** Total number of batches */
    totalBatches?: number;
    /** Average processing time per item */
    averageTimePerItem?: number;
}
interface BulkResult<T> {
    /** Successfully processed items and their results */
    successful: Array<{
        item: any;
        result: T;
        index: number;
    }>;
    /** Failed items and their errors */
    failed: Array<{
        item: any;
        error: Error;
        index: number;
        retries: number;
    }>;
    /** Skipped items (validation failed) */
    skipped: Array<{
        item: any;
        reason: string;
        index: number;
    }>;
    /** Total number of items */
    total: number;
    /** Number of successful items */
    successCount: number;
    /** Number of failed items */
    failureCount: number;
    /** Number of skipped items */
    skippedCount: number;
    /** Total processing duration in milliseconds */
    duration: number;
    /** Detailed metrics if enabled */
    metrics?: BulkMetrics;
}
interface BulkMetrics {
    /** Start time */
    startTime: Date;
    /** End time */
    endTime: Date;
    /** Total duration in milliseconds */
    totalDuration: number;
    /** Average time per item */
    averageTimePerItem: number;
    /** Fastest item processing time */
    fastestItem: number;
    /** Slowest item processing time */
    slowestItem: number;
    /** Processing times for each batch */
    batchTimes: number[];
    /** Retry statistics */
    retryStats: {
        totalRetries: number;
        successfulRetries: number;
        failedRetries: number;
    };
    /** Memory usage statistics */
    memoryStats?: {
        initial: number;
        peak: number;
        final: number;
    };
}
declare class BulkOperationManager<T = any> extends EventEmitter {
    private options;
    private readonly defaultOptions;
    constructor(options?: BulkOptions);
    /**
     * Execute a bulk operation on multiple items
     */
    execute<R>(items: T[], operation: (item: T, index: number) => Promise<R>, customOptions?: BulkOptions): Promise<BulkResult<R>>;
    /**
     * Process a single batch of items
     */
    private processBatch;
    /**
     * Execute an operation with retry logic
     */
    private executeWithRetry;
    /**
     * Create batches from items
     */
    private createBatches;
    /**
     * Validate a single item
     */
    private validateItem;
    /**
     * Update progress information
     */
    private updateProgress;
    /**
     * Update metrics with item processing time
     */
    private updateMetrics;
    /**
     * Sleep for specified milliseconds
     */
    private sleep;
    /**
     * Cancel ongoing bulk operation
     */
    cancel(): void;
}
declare function createBulkManager<T = any>(options?: BulkOptions): BulkOperationManager<T>;

export { type BulkMetrics, BulkOperationManager, type BulkOptions, type BulkProgress, type BulkResult, createBulkManager };