import { OnModuleInit } from '@nestjs/common';
import { AIService } from './ai.service';
import { AIProviderService } from './ai-provider.service';
import { ProjectService } from './project.service';
import { AgentInfo } from './agent.types';
import { ParallelProcessingService } from './services/parallel-processing.service';
import { TaskManagementService } from './services/task-management.service';
import { ResultFormatterService } from './services/result-formatter.service';
import { TemplateService } from './services/template.service';
import { DocumentLoaderService } from './services/document-loader.service';
import { ToolCallService } from './services/tool-call.service';
import { AgentLoaderService } from './services/agent-loader.service';
export declare class CodeCrewTool implements OnModuleInit {
    private readonly aiService;
    private readonly aiProviderService;
    private readonly projectService;
    private readonly parallelProcessingService;
    private readonly taskManagementService;
    private readonly resultFormatterService;
    private readonly templateService;
    private readonly documentLoaderService;
    private readonly toolCallService;
    private readonly agentLoaderService;
    private readonly logger;
    private generateSecurityKey;
    private buildToolsContext;
    constructor(aiService: AIService, aiProviderService: AIProviderService, projectService: ProjectService, parallelProcessingService: ParallelProcessingService, taskManagementService: TaskManagementService, resultFormatterService: ResultFormatterService, templateService: TemplateService, documentLoaderService: DocumentLoaderService, toolCallService: ToolCallService, agentLoaderService: AgentLoaderService);
    onModuleInit(): void;
    getTaskLogs(input: {
        taskId?: string;
    }): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        isError: boolean;
    }>;
    checkAIProviders(): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        availableProviders: string[];
        installation: {
            claude: boolean;
            gemini: boolean;
            copilot: boolean;
        };
        recommendations: string[];
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        availableProviders: never[];
        installation: {
            claude: {
                installed: boolean;
            };
            gemini: {
                installed: boolean;
            };
            copilot: {
                installed: boolean;
            };
        };
        recommendations?: undefined;
    }>;
    private getInstallationRecommendations;
    listAgents(): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        availableAgents: AgentInfo[];
        totalCount: number;
        configurationSource: string;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        availableAgents: never[];
        totalCount: number;
        configurationSource?: undefined;
    }>;
    queryAgent(args: {
        agentId: string;
        query: string;
        context?: string;
        model?: string;
        messages?: Array<{
            text: string;
            isAssistant: boolean;
            metadata?: Record<string, any>;
        }>;
        platform?: 'slack' | 'cli';
    }): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        agent: string;
        error: string;
        availableAgents: string[];
        readOnlyMode: boolean;
        taskId?: undefined;
        provider?: undefined;
        query?: undefined;
        response?: undefined;
        workingDirectory?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        taskId: string;
        success: boolean;
        agent: string;
        provider: "claude" | "gemini" | "copilot";
        query: string;
        response: string;
        readOnlyMode: boolean;
        error: string | undefined;
        workingDirectory: string;
        availableAgents?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        agent: string;
        error: string;
        readOnlyMode: boolean;
        availableAgents?: undefined;
        taskId?: undefined;
        provider?: undefined;
        query?: undefined;
        response?: undefined;
        workingDirectory?: undefined;
    }>;
    executeAgent(args: {
        agentId: string;
        task: string;
        projectPath?: string;
        context?: string;
        model?: string;
        messages?: Array<{
            text: string;
            isAssistant: boolean;
            metadata?: Record<string, any>;
        }>;
        platform?: 'slack' | 'cli';
    }): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        agent: string;
        error: string;
        availableAgents: string[];
        executionMode: boolean;
        taskId?: undefined;
        provider?: undefined;
        implementation?: undefined;
        recommendations?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        taskId: string;
        agent: string;
        provider: "claude" | "gemini" | "copilot";
        implementation: string;
        error: string | undefined;
        recommendations: never[];
        availableAgents?: undefined;
        executionMode?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        taskId: string;
        agent: string;
        provider: string;
        implementation: null;
        error: string;
        recommendations: never[];
        availableAgents?: undefined;
        executionMode?: undefined;
    }>;
    private getOptionsForAgent;
    queryAgentParallel(args: {
        queries: Array<{
            agentId: string;
            query: string;
            projectPath?: string;
            context?: string;
            model?: string;
            messages?: Array<{
                text: string;
                isAssistant: boolean;
                metadata?: Record<string, any>;
            }>;
            platform?: 'slack' | 'cli';
        }>;
    }): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        results: never[];
        summary?: undefined;
        performance?: undefined;
        readOnlyMode?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        summary: {
            totalQueries: number;
            successful: number;
            failed: number;
            totalDuration: number;
            averageDuration: number;
        };
        results: ({
            index: number;
            agentId: string;
            query: string;
            success: boolean;
            response: string | undefined;
            provider: "claude" | "gemini" | "copilot" | undefined;
            duration: number;
            taskId: string | undefined;
            error?: undefined;
        } | {
            index: number;
            agentId: string;
            query: string;
            success: boolean;
            error: any;
            duration: number;
            response?: undefined;
            provider?: undefined;
            taskId?: undefined;
        })[];
        performance: {
            fastestQuery: number;
            slowestQuery: number;
            timeSaved: number;
        };
        readOnlyMode: boolean;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        results: never[];
        readOnlyMode: boolean;
        summary?: undefined;
        performance?: undefined;
    }>;
    executeAgentParallel(args: {
        tasks: Array<{
            agentId: string;
            task: string;
            projectPath?: string;
            context?: string;
        }>;
    }): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        results: never[];
        summary?: undefined;
        performance?: undefined;
        executionMode?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        summary: {
            totalTasks: number;
            successful: number;
            failed: number;
            totalDuration: number;
            averageDuration: number;
        };
        results: ({
            index: number;
            agentId: string;
            task: string;
            success: boolean;
            implementation: string | undefined;
            provider: string | undefined;
            duration: number;
            error: string | undefined;
            context: string | undefined;
            workingDirectory: string;
            recommendations: never[];
            taskId: string | undefined;
        } | {
            index: number;
            agentId: string;
            task: string;
            success: boolean;
            implementation: null;
            provider: string;
            duration: number;
            error: any;
            context: string | undefined;
            workingDirectory: string;
            recommendations: never[];
            taskId: null;
        })[];
        performance: {
            fastestTask: number;
            slowestTask: number;
            timeSaved: number;
        };
        executionMode: boolean;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: string;
        results: never[];
        executionMode: boolean;
        summary?: undefined;
        performance?: undefined;
    }>;
    clearAllLogs(): Promise<{
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        message: string;
        path: string;
        totalFiles?: undefined;
        logFiles?: undefined;
        deletedCount?: undefined;
        totalSize?: undefined;
        deletedFiles?: undefined;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        message: string;
        path: string;
        totalFiles: number;
        logFiles: number;
        deletedCount?: undefined;
        totalSize?: undefined;
        deletedFiles?: undefined;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        message: string;
        path: string;
        deletedCount: number;
        totalSize: number;
        deletedFiles: string[];
        totalFiles?: undefined;
        logFiles?: undefined;
        error?: undefined;
    } | {
        content: {
            type: string;
            text: string;
        }[];
        success: boolean;
        error: any;
        message?: undefined;
        path?: undefined;
        totalFiles?: undefined;
        logFiles?: undefined;
        deletedCount?: undefined;
        totalSize?: undefined;
        deletedFiles?: undefined;
    }>;
    private getAvailableProvider;
}