/**
 * Agentic QE v3 - Coherence Gate Controller
 * ADR-030: 4-tier compute allocation based on lambda coherence
 *
 * Evaluates quality lambda and makes 4-tier deployment decisions.
 * Based on ruvector-mincut-gated-transformer's gate control patterns.
 */
import { QualityLambda, QualityTier, QualityGateDecision, CoherenceGatePolicy } from './types';
/**
 * Configuration for the coherence gate controller
 */
export interface CoherenceGateControllerConfig {
    /** Policy settings */
    policy: CoherenceGatePolicy;
    /** Enable detailed explanations */
    verboseExplanations: boolean;
    /** Store decision history */
    recordHistory: boolean;
    /** Maximum history entries to keep */
    maxHistoryEntries: number;
}
/**
 * Coherence Gate Controller
 * Makes 4-tier quality decisions based on lambda coherence metrics
 */
export declare class CoherenceGateController {
    private readonly config;
    private readonly lambdaCalculator;
    private readonly decisionHistory;
    constructor(config?: Partial<CoherenceGateControllerConfig>);
    /**
     * Evaluate quality lambda and return a 4-tier decision
     */
    evaluate(lambda: QualityLambda): QualityGateDecision;
    /**
     * Quick evaluation returning just the tier
     */
    evaluateTier(lambda: QualityLambda): QualityTier;
    /**
     * Check if deployment is allowed
     */
    canDeploy(lambda: QualityLambda): boolean;
    /**
     * Get the decision history
     */
    getHistory(): QualityGateDecision[];
    /**
     * Clear decision history
     */
    clearHistory(): void;
    /**
     * Get the current policy
     */
    getPolicy(): CoherenceGatePolicy;
    /**
     * Update policy settings
     * Note: This creates a new policy object to avoid mutating any shared references
     */
    updatePolicy(policy: Partial<CoherenceGatePolicy>): void;
    /**
     * Calculate drop ratio in Q15 format
     */
    private calculateDropRatio;
    /**
     * Check critical dimensions for failures
     */
    private checkCriticalDimensions;
    /**
     * Determine the final decision based on collected reasons
     */
    private determineDecision;
    /**
     * Create a complete decision object
     */
    private createDecision;
    /**
     * Convert decision string to tier enum
     */
    private decisionToTier;
    /**
     * Get recommended actions for a given tier
     */
    private getActionsForTier;
    /**
     * Calculate confidence in the decision
     */
    private calculateConfidence;
    /**
     * Generate human-readable explanation
     */
    private generateExplanation;
    /**
     * Get basic explanation for decision
     */
    private getBasicExplanation;
    /**
     * Convert reason enum to human-readable string
     */
    private reasonToString;
    /**
     * Get summary of dimension health
     */
    private getDimensionSummary;
    /**
     * Record decision in history
     */
    private recordDecision;
}
/**
 * Factory function to create a coherence gate controller
 */
export declare function createCoherenceGateController(config?: Partial<CoherenceGateControllerConfig>): CoherenceGateController;
/**
 * Convenience function to evaluate lambda and get decision
 */
export declare function evaluateQualityGate(lambda: QualityLambda, policy?: Partial<CoherenceGatePolicy>): QualityGateDecision;
//# sourceMappingURL=gate-controller.d.ts.map