/**
 * BATCH PROCESSING
 * Bulk operations, job queuing, progress tracking, result aggregation
 */
export declare enum BatchStatus {
    PENDING = "pending",
    PROCESSING = "processing",
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled",
    PARTIAL = "partial"
}
export declare enum JobStatus {
    QUEUED = "queued",
    RUNNING = "running",
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled"
}
export interface BatchRequest {
    id: string;
    items: BatchItem[];
    config: BatchConfig;
}
export interface BatchItem {
    id: string;
    data: Record<string, unknown>;
    priority?: number;
}
export interface BatchConfig {
    parallel?: number;
    timeout_ms?: number;
    retry_failed?: boolean;
    max_retries?: number;
    stop_on_error?: boolean;
    progress_callback?: (progress: BatchProgress) => void;
}
export interface BatchResult {
    id: string;
    status: BatchStatus;
    total: number;
    completed: number;
    failed: number;
    results: JobResult[];
    started_at: Date;
    completed_at?: Date;
    duration_ms?: number;
    error?: string;
}
export interface BatchProgress {
    batch_id: string;
    total: number;
    completed: number;
    failed: number;
    in_progress: number;
    percent: number;
    estimated_completion?: Date;
}
export interface Job {
    id: string;
    batch_id: string;
    item: BatchItem;
    status: JobStatus;
    attempts: number;
    result?: unknown;
    error?: string;
    started_at?: Date;
    completed_at?: Date;
    duration_ms?: number;
}
export interface JobResult {
    item_id: string;
    success: boolean;
    result?: unknown;
    error?: string;
    duration_ms: number;
    attempts: number;
}
export declare class BatchProcessor {
    private batches;
    private jobs;
    private queue;
    private active_jobs;
    /**
     * Submit batch for processing
     */
    submit(items: BatchItem[], processor: (item: BatchItem) => Promise<unknown>, config?: BatchConfig): Promise<string>;
    /**
     * Get batch status
     */
    getStatus(batch_id: string): BatchResult | null;
    /**
     * Get batch progress
     */
    getProgress(batch_id: string): BatchProgress | null;
    /**
     * Cancel batch
     */
    cancel(batch_id: string): boolean;
    /**
     * Retry failed jobs
     */
    retryFailed(batch_id: string): Promise<boolean>;
    /**
     * Get all batches
     */
    listBatches(): BatchResult[];
    /**
     * Delete batch
     */
    deleteBatch(batch_id: string): boolean;
    private processBatch;
    private processJob;
    private sleep;
    private generateId;
}
export declare class BatchBuilder {
    private items;
    private config;
    /**
     * Add item to batch
     */
    add(data: Record<string, unknown>, priority?: number): this;
    /**
     * Add multiple items
     */
    addMany(items: Array<{
        data: Record<string, unknown>;
        priority?: number;
    }>): this;
    /**
     * Set parallel execution limit
     */
    parallel(count: number): this;
    /**
     * Set timeout
     */
    timeout(ms: number): this;
    /**
     * Enable retry
     */
    retry(max_retries?: number): this;
    /**
     * Stop on first error
     */
    stopOnError(): this;
    /**
     * Set progress callback
     */
    onProgress(callback: (progress: BatchProgress) => void): this;
    /**
     * Build and submit batch
     */
    submit(processor: (item: BatchItem) => Promise<unknown>, batch_processor: BatchProcessor): Promise<string>;
    private generateId;
}
//# sourceMappingURL=batch-processor.d.ts.map