import { AIService } from '../ai.service';
import { TaskManagementService } from './task-management.service';
import { ConfigService } from './config.service';
interface AgentExecutionResult {
    agentId: string;
    success: boolean;
    result?: any;
    error?: string;
    duration: number;
    taskId?: string;
}
interface ParallelProcessingRequest {
    agentId: string;
    query?: string;
    task?: string;
    context?: string;
    projectPath?: string;
    messages?: Array<{
        text: string;
        isAssistant: boolean;
        metadata?: Record<string, any>;
    }>;
    platform?: 'slack' | 'cli';
}
interface ParallelProcessingConfig {
    maxConcurrency?: number;
    timeout?: number;
    failFast?: boolean;
}
export declare class ParallelProcessingService {
    private readonly aiService;
    private readonly taskManagementService;
    private readonly configService;
    private readonly logger;
    private readonly timeoutConfig;
    constructor(aiService: AIService, taskManagementService: TaskManagementService, configService: ConfigService);
    private getProviderForAgent;
    private getOptionsForAgent;
    executeParallel(requests: ParallelProcessingRequest[], config?: ParallelProcessingConfig): Promise<{
        results: AgentExecutionResult[];
        summary: {
            total: number;
            successful: number;
            failed: number;
            totalDuration: number;
            averageDuration: number;
        };
    }>;
    queryAgentsParallel(queries: Array<{
        agentId: string;
        query: string;
        context?: string;
        projectPath?: string;
        messages?: Array<{
            text: string;
            isAssistant: boolean;
            metadata?: Record<string, any>;
        }>;
        platform?: 'slack' | 'cli';
    }>, config?: ParallelProcessingConfig): Promise<{
        results: AgentExecutionResult[];
        summary: {
            total: number;
            successful: number;
            failed: number;
            totalDuration: number;
            averageDuration: number;
        };
    }>;
    executeAgentsParallel(tasks: Array<{
        agentId: string;
        task: string;
        context?: string;
        projectPath?: string;
    }>, config?: ParallelProcessingConfig): Promise<{
        results: AgentExecutionResult[];
        summary: {
            total: number;
            successful: number;
            failed: number;
            totalDuration: number;
            averageDuration: number;
        };
    }>;
    private executeWithTimeout;
    private chunkArray;
    getPerformanceMetrics(results: AgentExecutionResult[]): {
        totalAgents: number;
        successRate: number;
        averageExecutionTime: number;
        fastestExecution: number;
        slowestExecution: number;
        successfulAgents?: undefined;
        failedAgents?: undefined;
    } | {
        totalAgents: number;
        successRate: number;
        averageExecutionTime: number;
        fastestExecution: number;
        slowestExecution: number;
        successfulAgents: string[];
        failedAgents: {
            agentId: string;
            error: string | undefined;
        }[];
    };
}
export {};