/**
 * Agentic QE v3 - Phase Executor
 * ADR-032: Time Crystal Scheduling
 *
 * Executes test phases with quality-gated progression.
 * Integrates with the test-execution domain for actual test running.
 *
 * IMPORTANT: For REAL test execution, provide a TestRunner implementation:
 * - VitestTestRunner: Executes tests via Vitest subprocess
 * - JestTestRunner: Executes tests via Jest subprocess
 *
 * See test-runner.ts for real implementations.
 * The simulateRun() method is MOCK MODE ONLY for development/testing.
 */
import { TestPhase, PhaseResult, PhaseThresholds } from './types';
/**
 * Test runner interface - abstracts actual test execution
 */
export interface TestRunner {
    /**
     * Run tests for specified types
     *
     * @param testTypes - Types of tests to run
     * @param options - Execution options
     * @returns Test execution results
     */
    run(testTypes: string[], options: TestRunnerOptions): Promise<TestRunnerResult>;
}
/**
 * Test runner options
 */
export interface TestRunnerOptions {
    /** Maximum parallelism */
    parallelism: number;
    /** Timeout in milliseconds */
    timeout: number;
    /** Whether to collect coverage */
    collectCoverage: boolean;
    /** Whether to retry failed tests */
    retryFailed: boolean;
    /** Maximum retries for failed tests */
    maxRetries: number;
    /** Filter pattern for test files */
    filter?: string;
}
/**
 * Test runner result
 */
export interface TestRunnerResult {
    /** Total tests discovered */
    total: number;
    /** Tests that passed */
    passed: number;
    /** Tests that failed */
    failed: number;
    /** Tests that were skipped */
    skipped: number;
    /** Tests flagged as flaky */
    flaky: number;
    /** Code coverage percentage (0-1) */
    coverage: number;
    /** Execution duration in milliseconds */
    duration: number;
    /** Detailed test results (optional) */
    details?: TestDetail[];
}
/**
 * Individual test detail
 */
export interface TestDetail {
    /** Test name */
    name: string;
    /** Test file */
    file: string;
    /** Test status */
    status: 'passed' | 'failed' | 'skipped' | 'flaky';
    /** Duration in milliseconds */
    duration: number;
    /** Error message if failed */
    error?: string;
    /** Number of retries */
    retries?: number;
}
/**
 * Phase Executor
 *
 * Executes a test phase and evaluates quality gates.
 *
 * USAGE:
 * - For REAL tests: Provide a TestRunner (VitestTestRunner or JestTestRunner)
 * - For MOCK mode: Omit the runner (uses simulateRun with fake data - dev only)
 *
 * Example with real execution:
 * ```typescript
 * import { VitestTestRunner } from './test-runner';
 *
 * const runner = new VitestTestRunner({ cwd: '/path/to/project' });
 * const executor = new PhaseExecutor(phase, runner);
 * const result = await executor.run(); // REAL test results
 * ```
 */
export declare class PhaseExecutor {
    private readonly phase;
    private readonly runner?;
    private readonly timeout;
    private readonly mockMode;
    /**
     * Create a phase executor
     *
     * @param phase - The test phase to execute
     * @param runner - Test runner for REAL execution. If omitted, uses MOCK MODE.
     * @param timeout - Execution timeout (defaults to phase.expectedDuration * 2)
     */
    constructor(phase: TestPhase, runner?: TestRunner, timeout?: number);
    /**
     * Check if executor is in mock mode (no real test execution)
     */
    isMockMode(): boolean;
    /**
     * Execute the phase
     *
     * @returns Phase execution result with quality gate evaluation
     */
    run(): Promise<PhaseResult>;
    /**
     * MOCK MODE: Simulate test execution with deterministic fake data.
     *
     * WARNING: This method returns FAKE data for development/testing only.
     * For REAL test execution, provide a TestRunner (VitestTestRunner or JestTestRunner).
     *
     * The fake data is deterministic based on phase configuration to allow
     * predictable testing of the scheduler logic without requiring actual tests.
     */
    private simulateRun;
    /**
     * Get base test count based on phase type
     */
    private getBaseTestCount;
    /**
     * Get base pass rate based on phase type
     */
    private getBasePassRate;
    /**
     * Get base coverage based on phase type
     */
    private getBaseCoverage;
    /**
     * Evaluate quality gates
     *
     * @param metrics - Current metrics to evaluate
     * @returns True if all quality gates pass
     */
    private evaluateQualityGates;
    /**
     * Get the phase being executed
     */
    getPhase(): TestPhase;
}
/**
 * Quality Gate Evaluator
 *
 * Standalone utility for evaluating quality gates
 */
export declare class QualityGateEvaluator {
    private readonly thresholds;
    constructor(thresholds: PhaseThresholds);
    /**
     * Evaluate a phase result against thresholds
     */
    evaluate(result: PhaseResult): QualityGateResult;
    /**
     * Create a default evaluator for a phase
     */
    static forPhase(phase: TestPhase): QualityGateEvaluator;
}
/**
 * Quality gate evaluation result
 */
export interface QualityGateResult {
    /** Whether all gates passed */
    passed: boolean;
    /** Individual gate evaluations */
    gates: GateEvaluation[];
    /** Gates that failed */
    failedGates: GateEvaluation[];
    /** Human-readable summary */
    summary: string;
}
/**
 * Individual gate evaluation
 */
export interface GateEvaluation {
    /** Gate name */
    name: string;
    /** Threshold value */
    threshold: number;
    /** Actual value */
    actual: number;
    /** Whether gate passed */
    passed: boolean;
    /** Comparison type */
    comparison: 'gte' | 'lte' | 'eq';
}
/**
 * Create a mock test runner for testing
 */
export declare function createMockTestRunner(resultOverrides?: Partial<TestRunnerResult>): TestRunner;
/**
 * Create a failing test runner for testing error paths
 */
export declare function createFailingTestRunner(passRate?: number, coverage?: number): TestRunner;
//# sourceMappingURL=phase-executor.d.ts.map