/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import { Transform, Readable } from 'stream';
import { EventEmitter } from 'events';
import { ThreatIndicator, ThreatFeedResult } from '../types';
interface StreamingConfig {
    chunkSize: number;
    maxConcurrency: number;
    bufferSize: number;
    workerPoolSize: number;
    memoryThreshold: number;
    enableCompression: boolean;
    retryAttempts: number;
    timeout: number;
}
interface ChunkProcessor {
    process(chunk: Buffer): Promise<ThreatIndicator[]>;
}
interface ProcessingStats {
    itemsProcessed: number;
    chunksProcessed: number;
    errorsEncountered: number;
    processingTime: number;
    memoryUsage: NodeJS.MemoryUsage;
    throughput: number;
}
export declare class StreamingProcessor extends EventEmitter {
    private config;
    private workerPool;
    private processingQueue;
    private activeWorkers;
    private stats;
    private startTime;
    constructor(config?: Partial<StreamingConfig>);
    private initializeStats;
    private initializeWorkerPool;
    private replaceWorker;
    processStream(inputStream: Readable, _processor: ChunkProcessor, options: {
        processorType: 'csv' | 'json' | 'xml';
        onProgress?: (stats: ProcessingStats) => void;
        onChunkProcessed?: (indicators: ThreatIndicator[]) => void;
    }): Promise<ThreatFeedResult>;
    private processChunkWithWorker;
    private getAvailableWorker;
    private processWithWorker;
    private processQueue;
    private monitorMemoryUsage;
    private updateStats;
    createLargeDataStream(_filePath: string): Transform;
    private createHttpStream;
    private createFileStream;
    batchProcess(sources: Array<{
        source: string | Buffer | Readable;
        type: 'csv' | 'json' | 'xml';
    }>, options?: {
        maxConcurrency?: number;
        onSourceComplete?: (source: string, result: ThreatFeedResult) => void;
    }): Promise<ThreatFeedResult[]>;
    private createSimpleProcessor;
    getStats(): ProcessingStats;
    resetStats(): void;
    shutdown(): Promise<void>;
}
export declare function createOptimizedProcessor(options?: {
    type: 'high-throughput' | 'low-memory' | 'balanced';
    customConfig?: Partial<StreamingConfig>;
}): StreamingProcessor;
export {};
//# sourceMappingURL=StreamingProcessor.d.ts.map