/**
 * Agentic QE v3 - Lambda Calculator for Coherence-Gated Quality Gates
 * ADR-030: Calculates quality lambda (minimum cut) from metrics
 *
 * Lambda represents the "minimum cut" between acceptable and unacceptable quality states.
 * Based on ruvector-mincut-gated-transformer's coherence calculation patterns.
 */
import { QualityLambda, QualityDimensions, QualityMetricsInput, QualityLambdaFlags, CoherenceGatePolicy } from './types';
/**
 * Configuration for lambda calculation
 */
export interface LambdaCalculatorConfig {
    /** Policy settings for thresholds */
    policy: CoherenceGatePolicy;
    /** Dimension weights (default: equal weights) */
    dimensionWeights?: Partial<Record<keyof QualityDimensions, number>>;
    /** Critical dimensions that cannot be below threshold */
    criticalDimensions?: (keyof QualityDimensions)[];
}
/**
 * Calculator for quality lambda (minimum cut) values
 */
export declare class LambdaCalculator {
    private readonly policy;
    private readonly weights;
    private readonly criticalDimensions;
    constructor(config?: Partial<LambdaCalculatorConfig>);
    /**
     * Calculate quality lambda from raw metrics
     */
    calculate(metrics: QualityMetricsInput): QualityLambda;
    /**
     * Normalize raw metrics to 0-1 scale dimensions
     */
    normalizeMetrics(metrics: QualityMetricsInput): QualityDimensions;
    /**
     * Calculate the minimum cut (lambda) from dimensions
     * This is the weakest quality dimension, representing the "minimum cut" in the quality graph
     */
    calculateMinimumCut(dimensions: QualityDimensions): number;
    /**
     * Count dimensions that are at the boundary (near threshold, unstable)
     */
    countBoundaryEdges(dimensions: QualityDimensions): number;
    /**
     * Calculate boundary concentration in Q15 fixed-point format (0-32767)
     * Higher values indicate more concentrated instability
     */
    calculateBoundaryConcentration(dimensions: QualityDimensions): number;
    /**
     * Calculate control flags based on lambda and trend
     */
    calculateFlags(lambda: number, previousLambda?: number): QualityLambdaFlags;
    /**
     * Calculate the drop ratio in Q15 format (0-32767)
     * Used by gate controller to detect rapid quality degradation
     */
    calculateDropRatioQ15(lambda: QualityLambda): number;
    /**
     * Get weighted dimension score for a specific dimension
     */
    getWeightedScore(dimension: keyof QualityDimensions, value: number): number;
    /**
     * Check if a dimension is critical
     */
    isCriticalDimension(dimension: keyof QualityDimensions): boolean;
    /**
     * Get all dimensions below a specific threshold
     */
    getDimensionsBelowThreshold(dimensions: QualityDimensions, threshold?: number): Array<{
        dimension: keyof QualityDimensions;
        value: number;
        deficit: number;
    }>;
    /**
     * Calculate a summary of dimension health
     */
    getDimensionSummary(dimensions: QualityDimensions): {
        healthy: number;
        warning: number;
        critical: number;
        total: number;
    };
}
/**
 * Factory function to create a lambda calculator with default settings
 */
export declare function createLambdaCalculator(config?: Partial<LambdaCalculatorConfig>): LambdaCalculator;
/**
 * Convenience function to calculate lambda from metrics
 */
export declare function calculateQualityLambda(metrics: QualityMetricsInput, config?: Partial<LambdaCalculatorConfig>): QualityLambda;
//# sourceMappingURL=lambda-calculator.d.ts.map