/**
 * Test Scenario Engine for Multi-Scenario MCP Tool Testing
 * Orchestrates comprehensive testing with multiple scenarios per tool
 *
 * @internal
 * @module assessment/TestScenarioEngine
 */
import { Tool, CompatibilityCallToolResult } from "@modelcontextprotocol/sdk/types.js";
import { TestScenario } from "./TestDataGenerator.js";
import { ValidationResult } from "./ResponseValidator.js";
import { PerformanceConfig } from "./config/performanceConfig.js";
export interface ScenarioTestResult {
    scenario: TestScenario;
    executed: boolean;
    executionTime: number;
    response?: CompatibilityCallToolResult;
    error?: string;
    validation: ValidationResult;
}
export interface ComprehensiveToolTestResult {
    toolName: string;
    tested: boolean;
    totalScenarios: number;
    scenariosExecuted: number;
    scenariosPassed: number;
    scenariosFailed: number;
    overallStatus: "fully_working" | "partially_working" | "connectivity_only" | "broken" | "untested";
    confidence: number;
    executionTime: number;
    scenarioResults: ScenarioTestResult[];
    summary: {
        happyPathSuccess: boolean;
        edgeCasesHandled: number;
        edgeCasesTotal: number;
        boundariesRespected: number;
        boundariesTotal: number;
        errorHandlingWorks: boolean;
    };
    progressiveComplexity?: {
        minimalWorks: boolean;
        simpleWorks: boolean;
        failurePoint?: "minimal" | "simple" | "none";
    };
    recommendations: string[];
}
export declare class TestScenarioEngine {
    private testTimeout;
    private delayBetweenTests;
    /**
     * Create a new TestScenarioEngine.
     *
     * @param testTimeout - Timeout for each test in milliseconds (default from PerformanceConfig)
     * @param delayBetweenTests - Delay between tests for rate limiting (default: 0)
     * @param performanceConfig - Optional performance configuration for centralized tuning
     */
    constructor(testTimeout?: number, delayBetweenTests?: number, performanceConfig?: Partial<PerformanceConfig>);
    /**
     * Sleep for specified milliseconds (for rate limiting)
     */
    private sleep;
    /**
     * Test tool with progressive complexity to identify failure points
     */
    testProgressiveComplexity(tool: Tool, callTool: (name: string, params: Record<string, unknown>) => Promise<CompatibilityCallToolResult>): Promise<ComprehensiveToolTestResult["progressiveComplexity"]>;
    /**
     * Generate minimal parameters (only absolutely required fields)
     */
    private generateMinimalParams;
    /**
     * Generate simple parameters (required fields with simple values)
     */
    private generateSimpleParams;
    /**
     * Generate minimal value for a schema
     */
    private generateMinimalValue;
    /**
     * Run comprehensive testing for a tool with multiple scenarios
     */
    testToolComprehensively(tool: Tool, callTool: (name: string, params: Record<string, unknown>) => Promise<CompatibilityCallToolResult>): Promise<ComprehensiveToolTestResult>;
    /**
     * Execute a single test scenario
     */
    private executeScenario;
    /**
     * Determine overall status based on scenario results
     */
    private determineOverallStatus;
    /**
     * Calculate confidence score based on test coverage and results
     */
    private calculateConfidence;
    /**
     * Generate recommendations based on test results
     */
    private generateRecommendations;
    /**
     * Generate a detailed report for a tool test
     */
    static generateDetailedReport(result: ComprehensiveToolTestResult): string;
}
//# sourceMappingURL=TestScenarioEngine.d.ts.map