/**
 * Agentic QE v3 - Quality Gate Protocol
 * Cross-domain protocol for release candidate quality gate evaluation
 *
 * Trigger: Release candidate event
 * Participants: Queen, Quality Gate, Coverage, Regression, Security domains
 * Actions: Aggregate metrics, evaluate, ML risk assessment, recommend
 */
import { Result, DomainName, Severity } from '../../shared/types';
import { EventBus, MemoryBackend, AgentCoordinator } from '../../kernel/interfaces';
export declare const QualityGateProtocolEvents: {
    readonly QualityGateTriggered: "coordination.QualityGateTriggered";
    readonly QualityGateCompleted: "coordination.QualityGateCompleted";
    readonly DeploymentApproved: "coordination.DeploymentApproved";
    readonly DeploymentBlocked: "coordination.DeploymentBlocked";
};
/**
 * Release candidate information
 */
export interface ReleaseCandidate {
    id: string;
    version: string;
    branch: string;
    commitHash: string;
    buildId?: string;
    artifacts?: string[];
    createdAt: Date;
    metadata?: Record<string, unknown>;
}
/**
 * Aggregated metrics from all participating domains
 */
export interface AggregatedMetrics {
    coverage: {
        line: number;
        branch: number;
        function: number;
        statement: number;
        trend: 'improving' | 'declining' | 'stable';
    };
    testExecution: {
        total: number;
        passed: number;
        failed: number;
        skipped: number;
        passRate: number;
        flakyTests: number;
        duration: number;
    };
    quality: {
        overallScore: number;
        technicalDebt: number;
        codeSmells: number;
        duplications: number;
        criticalBugs: number;
    };
    security: {
        vulnerabilities: {
            critical: number;
            high: number;
            medium: number;
            low: number;
        };
        complianceScore: number;
        lastAuditDate?: Date;
    };
    defects: {
        regressionRisk: number;
        predictedDefects: number;
        hotspotCount: number;
    };
    collectedAt: Date;
    sources: DomainName[];
}
/**
 * Quality gate check result
 */
export interface GateCheckResult {
    name: string;
    category: 'coverage' | 'tests' | 'quality' | 'security' | 'regression';
    passed: boolean;
    blocking: boolean;
    value: number;
    threshold: number;
    severity: Severity;
    message: string;
}
/**
 * ML-based risk assessment result
 */
export interface RiskAssessment {
    overallRisk: number;
    riskLevel: Severity;
    confidence: number;
    factors: RiskFactor[];
    historicalComparison?: {
        similarReleases: number;
        successRate: number;
    };
    predictions: {
        defectProbability: number;
        rollbackProbability: number;
        incidentProbability: number;
    };
}
export interface RiskFactor {
    name: string;
    contribution: number;
    description: string;
    mitigationSuggestion?: string;
}
/**
 * Quality gate recommendation
 */
export interface QualityGateRecommendation {
    decision: 'approved' | 'blocked' | 'conditional';
    confidence: number;
    summary: string;
    blockingIssues: string[];
    warnings: string[];
    conditions?: string[];
    rollbackPlan?: string;
    nextSteps: string[];
}
/**
 * Complete quality gate evaluation result
 */
export interface QualityGateEvaluation {
    id: string;
    releaseCandidate: ReleaseCandidate;
    metrics: AggregatedMetrics;
    checks: GateCheckResult[];
    riskAssessment: RiskAssessment;
    recommendation: QualityGateRecommendation;
    duration: number;
    evaluatedAt: Date;
}
/**
 * Configuration for quality gate thresholds
 */
export interface QualityGateThresholds {
    coverage: {
        line: {
            min: number;
            blocking: boolean;
        };
        branch: {
            min: number;
            blocking: boolean;
        };
    };
    tests: {
        passRate: {
            min: number;
            blocking: boolean;
        };
        maxFlakyTests: {
            max: number;
            blocking: boolean;
        };
    };
    quality: {
        minScore: {
            min: number;
            blocking: boolean;
        };
        maxCriticalBugs: {
            max: number;
            blocking: boolean;
        };
    };
    security: {
        maxCriticalVulns: {
            max: number;
            blocking: boolean;
        };
        maxHighVulns: {
            max: number;
            blocking: boolean;
        };
        minComplianceScore: {
            min: number;
            blocking: boolean;
        };
    };
    regression: {
        maxRisk: {
            max: number;
            blocking: boolean;
        };
    };
}
/**
 * Protocol configuration
 */
export interface QualityGateProtocolConfig {
    thresholds: QualityGateThresholds;
    enableMLRiskAssessment: boolean;
    publishEvents: boolean;
    timeout: number;
    parallelMetricsCollection: boolean;
    storeEvaluationHistory: boolean;
}
export interface IQualityGateProtocol {
    /**
     * Execute quality gate evaluation for a release candidate
     */
    execute(releaseCandidate: ReleaseCandidate): Promise<Result<QualityGateEvaluation, Error>>;
    /**
     * Aggregate metrics from all participating domains
     */
    aggregateMetrics(releaseCandidate: ReleaseCandidate): Promise<Result<AggregatedMetrics, Error>>;
    /**
     * Evaluate quality gate checks against aggregated metrics
     */
    evaluateGate(metrics: AggregatedMetrics): Promise<Result<GateCheckResult[], Error>>;
    /**
     * Perform ML-based deployment risk assessment
     */
    assessRisk(metrics: AggregatedMetrics, checks: GateCheckResult[]): Promise<Result<RiskAssessment, Error>>;
    /**
     * Generate go/no-go recommendation
     */
    generateRecommendation(releaseCandidate: ReleaseCandidate, checks: GateCheckResult[], riskAssessment: RiskAssessment): Promise<Result<QualityGateRecommendation, Error>>;
    /**
     * Get evaluation history for a release
     */
    getEvaluationHistory(releaseId: string): Promise<QualityGateEvaluation[]>;
    /**
     * Update thresholds configuration
     */
    updateThresholds(thresholds: Partial<QualityGateThresholds>): void;
}
export declare class QualityGateProtocol implements IQualityGateProtocol {
    private readonly eventBus;
    private readonly memory;
    private readonly agentCoordinator;
    private config;
    private readonly participatingDomains;
    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<QualityGateProtocolConfig>);
    /**
     * Execute complete quality gate evaluation
     */
    execute(releaseCandidate: ReleaseCandidate): Promise<Result<QualityGateEvaluation, Error>>;
    /**
     * Aggregate metrics from all participating domains
     */
    aggregateMetrics(releaseCandidate: ReleaseCandidate): Promise<Result<AggregatedMetrics, Error>>;
    /**
     * Evaluate quality gate checks
     */
    evaluateGate(metrics: AggregatedMetrics): Promise<Result<GateCheckResult[], Error>>;
    /**
     * ML-based risk assessment
     */
    assessRisk(metrics: AggregatedMetrics, checks: GateCheckResult[]): Promise<Result<RiskAssessment, Error>>;
    /**
     * Generate go/no-go recommendation
     */
    generateRecommendation(releaseCandidate: ReleaseCandidate, checks: GateCheckResult[], riskAssessment: RiskAssessment): Promise<Result<QualityGateRecommendation, Error>>;
    /**
     * Get evaluation history for a release
     */
    getEvaluationHistory(releaseId: string): Promise<QualityGateEvaluation[]>;
    /**
     * Update thresholds configuration
     */
    updateThresholds(thresholds: Partial<QualityGateThresholds>): void;
    private getCoverageMetrics;
    private getTestExecutionMetrics;
    private getQualityMetrics;
    private getSecurityMetrics;
    private getDefectMetrics;
    private createCheck;
    private determineCheckSeverity;
    private createBasicRiskAssessment;
    private calculateRiskFactors;
    private calculateOverallRisk;
    private getHistoricalComparison;
    private calculatePredictions;
    private calculateConfidence;
    private riskScoreToSeverity;
    private generateSummary;
    private generateConditions;
    private generateRollbackPlan;
    private generateNextSteps;
    private calculateRecommendationConfidence;
    private publishQualityGateTriggered;
    private publishGateCompleted;
    private publishDeploymentApproved;
    private publishDeploymentBlocked;
    private storeEvaluation;
    /**
     * Spawn a coordinator agent for the quality gate evaluation
     */
    private spawnCoordinatorAgent;
    /**
     * Stop the coordinator agent after evaluation completes
     */
    private stopCoordinatorAgent;
}
export declare function createQualityGateProtocol(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<QualityGateProtocolConfig>): IQualityGateProtocol;
//# sourceMappingURL=quality-gate.d.ts.map