import { TranslationRequest, TranslationResult, SupportedLanguage } from './types';
import { SmartBatchOptimizer } from './smart-batch-optimizer';
import { OptimizedCacheManager } from './optimized-cache-manager';
/**
 * 超级批量处理配置
 */
export interface SuperBatchConfig {
    enabled: boolean;
    maxBatchSize: number;
    minBatchSize: number;
    batchTimeout: number;
    enableStreamProcessing: boolean;
    streamChunkSize: number;
    enablePipelineOptimization: boolean;
    pipelineStages: number;
    enableIntelligentGrouping: boolean;
    groupingAlgorithm: 'similarity' | 'length' | 'complexity' | 'hybrid';
    similarityThreshold: number;
    enableMemoryOptimization: boolean;
    maxMemoryUsage: number;
    enableGarbageCollection: boolean;
    maxConcurrentBatches: number;
    adaptiveConcurrency: boolean;
    concurrencyScalingFactor: number;
    enableSmartRetry: boolean;
    maxRetryAttempts: number;
    retryDelayMultiplier: number;
    errorRecoveryStrategy: 'fail-fast' | 'partial-success' | 'full-retry';
}
/**
 * 批处理统计信息
 */
export interface BatchingStats {
    totalRequests: number;
    batchesCreated: number;
    averageBatchSize: number;
    optimalBatchSize: number;
    processingTime: number;
    memoryEfficiency: number;
    concurrencyUtilization: number;
    errorRate: number;
    throughput: number;
    cacheSavings: number;
}
/**
 * 智能文本分组结果
 */
export interface IntelligentGroup {
    id: string;
    requests: TranslationRequest[];
    groupType: 'similar' | 'length-based' | 'complexity-based' | 'mixed';
    characteristics: {
        averageLength: number;
        complexity: number;
        similarity: number;
        estimatedProcessingTime: number;
    };
    priority: number;
}
/**
 * 流式处理状态
 */
export interface StreamProcessingState {
    totalChunks: number;
    processedChunks: number;
    currentChunk: number;
    estimatedTimeRemaining: number;
    throughputRate: number;
    memoryUsage: number;
}
/**
 * 管道阶段定义
 */
export interface PipelineStage {
    id: string;
    name: string;
    processor: (data: any) => Promise<any>;
    concurrency: number;
    memoryLimit: number;
    timeoutMs: number;
}
/**
 * 超级批量翻译优化器 - 专为大规模高性能批量翻译设计
 */
export declare class SuperBatchTranslationOptimizer {
    private config;
    private baseOptimizer;
    private cacheManager;
    private profiler;
    private stats;
    private activeStreams;
    private pipeline;
    private memoryMonitor;
    private adaptiveMetrics;
    constructor(baseOptimizer: SmartBatchOptimizer, cacheManager: OptimizedCacheManager, config?: Partial<SuperBatchConfig>);
    /**
     * 超级批量翻译 - 主入口方法
     */
    superBatchTranslate(requests: TranslationRequest[], targetLanguage: SupportedLanguage, onProgress?: (progress: number, stats: BatchingStats) => void): Promise<TranslationResult[]>;
    /**
     * 流式批量翻译 - 适用于超大规模数据
     */
    streamBatchTranslate(requests: TranslationRequest[], targetLanguage: SupportedLanguage, onChunkComplete?: (chunk: TranslationResult[], state: StreamProcessingState) => void): Promise<TranslationResult[]>;
    /**
     * 管道式批量翻译 - 多阶段并行处理
     */
    pipelineBatchTranslate(requests: TranslationRequest[], targetLanguage: SupportedLanguage, onStageComplete?: (stage: string, progress: number) => void): Promise<TranslationResult[]>;
    /**
     * 分析请求特征
     */
    private analyzeRequests;
    /**
     * 执行智能分组
     */
    private performIntelligentGrouping;
    /**
     * 基于相似度分组
     */
    private groupBySimilarity;
    /**
     * 基于长度分组
     */
    private groupByLength;
    /**
     * 混合分组策略
     */
    private hybridGrouping;
    /**
     * 选择最优处理策略
     */
    private selectOptimalStrategy;
    /**
     * 执行超级批量处理
     */
    private executeSuperBatch;
    /**
     * 处理单个组
     */
    private processGroup;
    /**
     * 计算最优chunk大小
     */
    private calculateOptimalChunkSize;
    /**
     * 内存压力检查
     */
    private checkMemoryPressure;
    /**
     * 初始化处理管道
     */
    private initializePipeline;
    /**
     * 启动内存监控
     */
    private startMemoryMonitoring;
    private calculateTextComplexity;
    private getTextComplexity;
    private calculateTextSimilarity;
    private calculateTextSimilarityScore;
    private estimateProcessingTime;
    private getCurrentMemoryUsage;
    private createEmptyStats;
    /**
     * 清理资源
     */
    private fallbackToBatch;
    private performPostProcessing;
    private createChunks;
    private processSingleChunk;
    private adjustConcurrencyBasedOnPerformance;
    private detectTextType;
    private recommendProcessingStrategy;
    private estimateMemoryUsage;
    private calculateOptimalConcurrency;
    private groupByComplexity;
    private updateGroupCharacteristics;
    private mergeSmallGroups;
    private updateStats;
    private processGroupsInParallel;
    private processGroupsInPipeline;
    private processGroupsAsStream;
    private checkGroupCache;
    private filterUncachedRequests;
    private cacheGroupResults;
    private retryGroupProcessing;
    private preprocessText;
    private batchCacheCheck;
    cleanup(): void;
}
/**
 * 高性能批量翻译工厂
 */
export declare class SuperBatchTranslationFactory {
    static create(baseOptimizer: SmartBatchOptimizer, cacheManager: OptimizedCacheManager, config?: Partial<SuperBatchConfig>): SuperBatchTranslationOptimizer;
    static createWithDefaults(): SuperBatchTranslationOptimizer;
    private fallbackToBatch;
    private performPostProcessing;
    private createChunks;
    private processSingleChunk;
    private adjustConcurrencyBasedOnPerformance;
    private detectTextType;
    private recommendProcessingStrategy;
    private estimateMemoryUsage;
    private calculateOptimalConcurrency;
    private groupByComplexity;
    private updateGroupCharacteristics;
    private mergeSmallGroups;
    private updateStats;
    private processGroupsInParallel;
    private processGroupsInPipeline;
    private processGroupsAsStream;
}
//# sourceMappingURL=super-batch-translation-optimizer.d.ts.map