import { Logger } from '../types';
export interface BatchItem {
    id: string;
    priority: number;
    retryCount: number;
    status: 'pending' | 'processing' | 'completed' | 'failed' | 'skipped';
    data?: unknown;
    error?: string;
}
export interface BatchProcessorOptions {
    batchSize: number;
    concurrency: number;
    rateLimitDelay: number;
    maxRetries: number;
    retryDelay: number;
    exponentialBackoff?: boolean;
    memoryThreshold?: number;
    onProgress?: (processed: number, total: number, current?: BatchItem) => void;
    onBatchComplete?: (batch: BatchItem[], batchIndex: number, totalBatches: number) => void;
    onItemComplete?: (item: BatchItem, success: boolean) => void;
    onError?: (item: BatchItem, error: Error, attempt: number) => void;
}
export interface BatchProcessorResult<T extends BatchItem> {
    totalItems: number;
    processedItems: number;
    successfulItems: number;
    failedItems: number;
    skippedItems: number;
    items: T[];
    duration: number;
    averageProcessingTime: number;
}
export declare class BatchProcessor<T extends BatchItem> {
    private readonly logger;
    private readonly options;
    private isProcessing;
    private shouldCancel;
    private currentBatch;
    private startTime;
    private processedCount;
    constructor(logger: Logger, options: BatchProcessorOptions);
    process<R>(items: T[], processor: (item: T) => Promise<R>): Promise<BatchProcessorResult<T>>;
    cancel(): void;
    isRunning(): boolean;
    getStatistics(): {
        isProcessing: boolean;
        processedCount: number;
        currentBatch: T[];
        elapsedTime: number;
        averageProcessingTime: number;
    };
    private processBatch;
    private processItem;
    private createBatches;
    private calculateRetryDelay;
    private checkMemoryUsage;
    private getTotalItems;
    private generateResult;
    private delay;
}
export declare class RateLimiter {
    private readonly requestsPerSecond;
    private readonly burstSize;
    private tokens;
    private lastRefill;
    private queue;
    constructor(_logger: Logger, requestsPerSecond: number, burstSize?: number);
    waitForPermission(): Promise<void>;
    private tryAcquire;
    private refillTokens;
    private scheduleRefill;
    getStatus(): {
        tokens: number;
        queueLength: number;
        requestsPerSecond: number;
    };
}
//# sourceMappingURL=batch-processor.d.ts.map