observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/quality/quality-feature-engineering.d.ts

@@ -0,0 +1,1071 @@
+/**
+ * Feature Engineering for Evaluation Analytics (Design Doc Section 16)
+ *
+ * Derived features, adaptive score scaling, label encoding, and composite metrics
+ * computed from existing evaluation data. Enhances anomaly detection, correlation
+ * discovery, and role-appropriate information presentation.
+ *
+ * @see quality-metrics.ts for core types
+ * @see frontend/docs/llm-explainability-design.md Section 16
+ */
+import { z } from 'zod';
+import { type ConfidenceIndicator, type MetricTrend, type QualityMetricResult, type ThresholdDirection } from './quality-metrics.js';
+import { type RoleType, type CQIWeights } from './quality-constants.js';
+/**
+ * Score direction for color mapping (higher-is-better vs lower-is-better).
+ * Semantically distinct from ThresholdDirection ('above'/'below') which controls
+ * alert trigger conditions. ScoreDirection controls visual presentation.
+ */
+export type ScoreDirection = 'maximize' | 'minimize';
+/**
+ * Per-metric scaling strategy for adaptive score coloring.
+ * Different metrics have different native distributions, requiring
+ * different mapping strategies to the 5-band color scale.
+ */
+export type ScaleStrategy = 'quantile' | 'binary' | 'uniform' | 'log' | 'step' | 'categorical' | 'percentile_rank';
+/** Default scale strategy per metric */
+export declare const METRIC_SCALE_STRATEGY: Record<string, ScaleStrategy>;
+/** Score color band names */
+export type ScoreColorBand = 'excellent' | 'good' | 'adequate' | 'poor' | 'failing';
+/**
+ * Map a score value to a 5-band color band with direction awareness.
+ * For 'minimize' metrics (hallucination, latency), low scores are excellent.
+ * For 'maximize' metrics (relevance, faithfulness), high scores are excellent.
+ */
+export declare function scoreColorBand(value: number, direction?: ScoreDirection): ScoreColorBand;
+/** Percentile distribution for quantile-based scaling */
+export interface PercentileDistribution {
+    p10: number;
+    p25: number;
+    p50: number;
+    p75: number;
+    p90: number;
+}
+/**
+ * Zod schemas for runtime validation of quality feature types.
+ * Used for state persistence and API data validation.
+ */
+export declare const percentileDistributionSchema: z.ZodObject<{
+    p10: z.ZodNumber;
+    p25: z.ZodNumber;
+    p50: z.ZodNumber;
+    p75: z.ZodNumber;
+    p90: z.ZodNumber;
+}, z.core.$strip>;
+export type PercentileDistributionInput = z.infer<typeof percentileDistributionSchema>;
+export declare const scoreDirectionSchema: z.ZodEnum<{
+    maximize: "maximize";
+    minimize: "minimize";
+}>;
+export type ScoreDirectionInput = z.infer<typeof scoreDirectionSchema>;
+export declare const scaleStrategySchema: z.ZodEnum<{
+    binary: "binary";
+    step: "step";
+    categorical: "categorical";
+    quantile: "quantile";
+    uniform: "uniform";
+    log: "log";
+    percentile_rank: "percentile_rank";
+}>;
+export type ScaleStrategyInput = z.infer<typeof scaleStrategySchema>;
+export declare const scoreColorBandSchema: z.ZodEnum<{
+    excellent: "excellent";
+    good: "good";
+    adequate: "adequate";
+    poor: "poor";
+    failing: "failing";
+}>;
+export type ScoreColorBandInput = z.infer<typeof scoreColorBandSchema>;
+export declare const degradationStateSchema: z.ZodObject<{
+    lastRun: z.ZodString;
+    breaches: z.ZodRecord<z.ZodString, z.ZodInt>;
+}, z.core.$strip>;
+export type DegradationStateInput = z.infer<typeof degradationStateSchema>;
+export declare const calibrationStateSchema: z.ZodObject<{
+    lastCalibrated: z.ZodString;
+    distributions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        distribution: z.ZodObject<{
+            p10: z.ZodNumber;
+            p25: z.ZodNumber;
+            p50: z.ZodNumber;
+            p75: z.ZodNumber;
+            p90: z.ZodNumber;
+        }, z.core.$strip>;
+        sampleSize: z.ZodInt;
+        windowStart: z.ZodString;
+        windowEnd: z.ZodString;
+    }, z.core.$strip>>;
+    psiValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    rawScores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+export type CalibrationStateInput = z.infer<typeof calibrationStateSchema>;
+export declare const psiResultSchema: z.ZodObject<{
+    psi: z.ZodNumber;
+    drifted: z.ZodBoolean;
+}, z.core.$strip>;
+export type PSIResultInput = z.infer<typeof psiResultSchema>;
+export declare const backtestConfigSchema: z.ZodObject<{
+    varianceThreshold: z.ZodNumber;
+    coverageDropoutThreshold: z.ZodNumber;
+    latencySkewThreshold: z.ZodNumber;
+    confirmationWindow: z.ZodInt;
+    ewmaLambda: z.ZodOptional<z.ZodNumber>;
+    stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const backtestSnapshotSchema: z.ZodObject<{
+    currentStdDev: z.ZodNumber;
+    baselineStdDev: z.ZodNumber;
+    coverageGapCount: z.ZodInt;
+    totalCoverageCells: z.ZodInt;
+    latencyP95: z.ZodOptional<z.ZodNumber>;
+    latencyP50: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taprMetricsSchema: z.ZodObject<{
+    precision: z.ZodNumber;
+    recall: z.ZodNumber;
+    f1: z.ZodNumber;
+    detectionDelay: z.ZodNumber;
+}, z.core.$strip>;
+export declare const degradationBacktestResultSchema: z.ZodObject<{
+    config: z.ZodObject<{
+        varianceThreshold: z.ZodNumber;
+        coverageDropoutThreshold: z.ZodNumber;
+        latencySkewThreshold: z.ZodNumber;
+        confirmationWindow: z.ZodInt;
+        ewmaLambda: z.ZodOptional<z.ZodNumber>;
+        stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    truePositives: z.ZodInt;
+    falsePositives: z.ZodInt;
+    falseNegatives: z.ZodInt;
+    trueNegatives: z.ZodInt;
+    tapr: z.ZodObject<{
+        precision: z.ZodNumber;
+        recall: z.ZodNumber;
+        f1: z.ZodNumber;
+        detectionDelay: z.ZodNumber;
+    }, z.core.$strip>;
+    pointPrecision: z.ZodNumber;
+    pointRecall: z.ZodNumber;
+    pointF1: z.ZodNumber;
+}, z.core.$strip>;
+export declare const backtestSweepResultSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        config: z.ZodObject<{
+            varianceThreshold: z.ZodNumber;
+            coverageDropoutThreshold: z.ZodNumber;
+            latencySkewThreshold: z.ZodNumber;
+            confirmationWindow: z.ZodInt;
+            ewmaLambda: z.ZodOptional<z.ZodNumber>;
+            stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        truePositives: z.ZodInt;
+        falsePositives: z.ZodInt;
+        falseNegatives: z.ZodInt;
+        trueNegatives: z.ZodInt;
+        tapr: z.ZodObject<{
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodNumber;
+            detectionDelay: z.ZodNumber;
+        }, z.core.$strip>;
+        pointPrecision: z.ZodNumber;
+        pointRecall: z.ZodNumber;
+        pointF1: z.ZodNumber;
+    }, z.core.$strip>>;
+    bestByF1: z.ZodObject<{
+        config: z.ZodObject<{
+            varianceThreshold: z.ZodNumber;
+            coverageDropoutThreshold: z.ZodNumber;
+            latencySkewThreshold: z.ZodNumber;
+            confirmationWindow: z.ZodInt;
+            ewmaLambda: z.ZodOptional<z.ZodNumber>;
+            stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        truePositives: z.ZodInt;
+        falsePositives: z.ZodInt;
+        falseNegatives: z.ZodInt;
+        trueNegatives: z.ZodInt;
+        tapr: z.ZodObject<{
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodNumber;
+            detectionDelay: z.ZodNumber;
+        }, z.core.$strip>;
+        pointPrecision: z.ZodNumber;
+        pointRecall: z.ZodNumber;
+        pointF1: z.ZodNumber;
+    }, z.core.$strip>;
+    bestByRecall: z.ZodObject<{
+        config: z.ZodObject<{
+            varianceThreshold: z.ZodNumber;
+            coverageDropoutThreshold: z.ZodNumber;
+            latencySkewThreshold: z.ZodNumber;
+            confirmationWindow: z.ZodInt;
+            ewmaLambda: z.ZodOptional<z.ZodNumber>;
+            stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        truePositives: z.ZodInt;
+        falsePositives: z.ZodInt;
+        falseNegatives: z.ZodInt;
+        trueNegatives: z.ZodInt;
+        tapr: z.ZodObject<{
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodNumber;
+            detectionDelay: z.ZodNumber;
+        }, z.core.$strip>;
+        pointPrecision: z.ZodNumber;
+        pointRecall: z.ZodNumber;
+        pointF1: z.ZodNumber;
+    }, z.core.$strip>;
+    currentConfigResult: z.ZodObject<{
+        config: z.ZodObject<{
+            varianceThreshold: z.ZodNumber;
+            coverageDropoutThreshold: z.ZodNumber;
+            latencySkewThreshold: z.ZodNumber;
+            confirmationWindow: z.ZodInt;
+            ewmaLambda: z.ZodOptional<z.ZodNumber>;
+            stabilityThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        truePositives: z.ZodInt;
+        falsePositives: z.ZodInt;
+        falseNegatives: z.ZodInt;
+        trueNegatives: z.ZodInt;
+        tapr: z.ZodObject<{
+            precision: z.ZodNumber;
+            recall: z.ZodNumber;
+            f1: z.ZodNumber;
+            detectionDelay: z.ZodNumber;
+        }, z.core.$strip>;
+        pointPrecision: z.ZodNumber;
+        pointRecall: z.ZodNumber;
+        pointF1: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ahpComparisonSchema: z.ZodObject<{
+    metricA: z.ZodString;
+    metricB: z.ZodString;
+    preference: z.ZodPipe<z.ZodEnum<{
+        1: "1";
+        3: "3";
+        5: "5";
+        7: "7";
+        9: "9";
+    }>, z.ZodTransform<1 | 7 | 3 | 5 | 9, "1" | "3" | "5" | "7" | "9">>;
+    preferred: z.ZodEnum<{
+        A: "A";
+        B: "B";
+    }>;
+}, z.core.$strip>;
+export type AHPComparisonInput = z.infer<typeof ahpComparisonSchema>;
+export declare const tunedCQIWeightsSchema: z.ZodObject<{
+    featureVersion: z.ZodString;
+    weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    ahpWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    criticWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    alpha: z.ZodNumber;
+    consistencyRatio: z.ZodNumber;
+    incidentCorrelations: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Compute empirical CDF position for a value within a percentile distribution.
+ * Returns 0-1 representing where the value falls in the empirical distribution.
+ * Uses linear interpolation between known percentile points.
+ */
+export declare function empiricalCDF(value: number, dist: PercentileDistribution): number;
+/**
+ * Minimum sample size for quantile-based scaling to be considered valid.
+ * Below this threshold, quantile scaling falls back to uniform even when
+ * distribution data is provided (insufficient data for reliable percentiles).
+ */
+export declare const MIN_QUANTILE_SAMPLE_SIZE = 100;
+/**
+ * Adaptive score color band using per-metric scaling strategies.
+ * Falls back to uniform scoreColorBand when distribution data is unavailable.
+ *
+ * @param value - Raw score value
+ * @param metric - Metric name (used to look up ScaleStrategy)
+ * @param direction - Score direction (maximize or minimize)
+ * @param distribution - Optional empirical percentile distribution for quantile scaling
+ * @param sampleSize - Number of samples used to compute distribution; quantile requires >= 100
+ * @example
+ * ```ts
+ * adaptiveScoreColorBand(0.92, 'relevance');                   // 'excellent' (uniform, maximize)
+ * adaptiveScoreColorBand(0.3, 'hallucination', 'minimize');    // 'excellent' (low hallucination is good)
+ * adaptiveScoreColorBand(0.5, 'coherence', 'maximize', dist, 200); // quantile-scaled band
+ * ```
+ */
+export declare function adaptiveScoreColorBand(value: number, metric: string, direction?: ScoreDirection, distribution?: PercentileDistribution, sampleSize?: number): ScoreColorBand;
+/**
+ * Metrics where lower scores are better. Used as fallback when alert
+ * configuration is unavailable for direction inference.
+ */
+export declare const MINIMIZE_METRICS: Set<string>;
+/**
+ * Infer ScoreDirection from a metric's alert configuration.
+ * Metrics whose primary alert fires on 'below' are 'maximize' metrics.
+ * Metrics whose primary alert fires on 'above' are 'minimize' metrics.
+ */
+export declare function inferScoreDirection(alertDirection: ThresholdDirection | undefined): ScoreDirection;
+/** Filter category for evaluation table */
+export type LabelFilterCategory = 'Pass' | 'Review' | 'Fail';
+/** Label ordinal mapping result */
+export interface LabelOrdinal {
+    /** Numeric ordinal (0-4, higher = better) */
+    ordinal: number;
+    /** 3-tier filter category */
+    category: LabelFilterCategory;
+    /** Whether the label was found in the lookup table */
+    mapped: boolean;
+}
+/**
+ * Convert a free-text score label to an ordinal value for sorting/filtering.
+ * Unmapped labels default to ordinal 2 ("Review") with mapped=false.
+ *
+ * @param label - Free-text score label from EvaluationResult.scoreLabel
+ * @returns Ordinal encoding with category and mapping status
+ */
+export declare function labelToOrdinal(label: string): LabelOrdinal;
+/**
+ * Get the label filter category for a given ordinal value.
+ */
+export declare function ordinalToCategory(ordinal: number): LabelFilterCategory;
+/** CQI per-metric contribution breakdown */
+export declare const cqiContributionSchema: z.ZodObject<{
+    metric: z.ZodString;
+    rawScore: z.ZodNumber;
+    normalizedScore: z.ZodNumber;
+    weight: z.ZodNumber;
+    contribution: z.ZodNumber;
+}, z.core.$strip>;
+export type CQIContribution = z.infer<typeof cqiContributionSchema>;
+/** Composite Quality Index result */
+export declare const compositeQualityIndexSchema: z.ZodObject<{
+    featureVersion: z.ZodString;
+    value: z.ZodNumber;
+    weights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    contributions: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        rawScore: z.ZodNumber;
+        normalizedScore: z.ZodNumber;
+        weight: z.ZodNumber;
+        contribution: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CompositeQualityIndex = z.infer<typeof compositeQualityIndexSchema>;
+/** Default CQI weights per design doc Section 16.3 */
+export declare const DEFAULT_CQI_WEIGHTS: CQIWeights;
+/**
+ * Compute Composite Quality Index from metric results.
+ * Direction-normalizes scores before weighting (minimize metrics are inverted).
+ * Metrics with no data are excluded; weights are renormalized over available metrics.
+ *
+ * @param metrics - Quality metric results from dashboard summary
+ * @param weights - Optional custom weights (default: DEFAULT_CQI_WEIGHTS)
+ * @returns CQI result, or undefined if no metrics have data
+ * @example
+ * ```ts
+ * const cqi = computeCQI(dashboardSummary.metrics);
+ * // { score: 0.82, band: 'good', contributions: [...], featureVersion: '1.0' }
+ *
+ * // Custom weights emphasizing relevance
+ * const custom = computeCQI(metrics, { relevance: 0.4, faithfulness: 0.3, coherence: 0.3 });
+ * ```
+ */
+export declare function computeCQI(metrics: QualityMetricResult[], weights?: CQIWeights): CompositeQualityIndex | undefined;
+/** Per-weight sensitivity result */
+export interface CQISensitivityEntry {
+    metric: string;
+    baseWeight: number;
+    low: number;
+    high: number;
+    range: number;
+}
+/** CQI sensitivity analysis result */
+export interface CQISensitivity {
+    baseValue: number;
+    delta: number;
+    entries: CQISensitivityEntry[];
+}
+/**
+ * Compute CQI sensitivity by perturbing each weight +/- delta.
+ * Reports the CQI range when each weight varies independently.
+ *
+ * Only metrics with positive base weights are analyzed. Perturbed weights are
+ * not renormalized — computeCQI handles renormalization internally, so the
+ * sensitivity reflects the effect of shifting one weight's relative importance.
+ *
+ * @param metrics - Quality metric results
+ * @param weights - Base weights (default: DEFAULT_CQI_WEIGHTS)
+ * @param delta - Perturbation amount (default: 0.05)
+ * @returns Sensitivity analysis, or undefined if CQI cannot be computed
+ * @example
+ * ```ts
+ * const sens = computeCQISensitivity(metrics);
+ * // { baseValue: 0.82, delta: 0.05, entries: [
+ * //   { metric: 'relevance', baseWeight: 0.25, low: 0.80, high: 0.84, range: 0.04 },
+ * //   ...
+ * // ]}
+ * ```
+ */
+export declare function computeCQISensitivity(metrics: QualityMetricResult[], weights?: CQIWeights, delta?: number): CQISensitivity | undefined;
+/** Metric dynamics: velocity, acceleration, and breach projection */
+export interface MetricDynamics {
+    featureVersion: string;
+    /** Rate of change per hour */
+    velocity: number;
+    /** Change in velocity per hour */
+    acceleration: number;
+    /** True when acceleration sign flips (inflection point) */
+    inflectionDetected: boolean;
+    /** Linear projection of status based on current velocity */
+    projectedStatus: 'healthy' | 'warning' | 'critical';
+    /** ISO timestamp when threshold would be breached at current velocity */
+    projectedBreachTime?: string;
+    /** Confidence in dynamics estimate (0-1). Higher with more trend history and smoothing. */
+    confidence: number;
+}
+/**
+ * Compute metric dynamics from consecutive trend snapshots.
+ * When trendHistory is provided, applies exponential smoothing (alpha=0.3)
+ * to suppress noise amplification from second derivatives.
+ *
+ * @param currentTrend - Current period trend
+ * @param previousTrend - Previous period trend (for acceleration)
+ * @param periodHours - Length of each period in hours
+ * @param thresholds - Alert thresholds for breach projection
+ * @param trendHistory - Optional array of historical trends (oldest first) for EMA smoothing
+ * @returns Metric dynamics, or undefined if insufficient data
+ * @example
+ * ```ts
+ * const dynamics = computeMetricDynamics(
+ *   { currentValue: 0.85, previousValue: 0.80, delta: 0.05 },
+ *   { currentValue: 0.80, previousValue: 0.78, delta: 0.02 },
+ *   1, // 1-hour periods
+ *   [{ value: 0.7, direction: 'below', severity: 'warning' }]
+ * );
+ * // { velocity: 0.05, acceleration: 0.03, confidence: 0.5, projectedStatus: 'healthy', ... }
+ * ```
+ */
+export declare function computeMetricDynamics(currentTrend: MetricTrend, previousTrend: MetricTrend | undefined, periodHours: number, thresholds?: Array<{
+    value: number;
+    direction: ThresholdDirection;
+    severity: 'warning' | 'critical';
+}>, trendHistory?: MetricTrend[]): MetricDynamics | undefined;
+/** Extended confidence with coverage uniformity */
+export interface CoverageWeightedConfidence extends ConfidenceIndicator {
+    featureVersion: string;
+    /** Coverage uniformity (0-1), normalized Shannon entropy of evaluations per input */
+    coverageUniformity: number;
+    /** Effective sample size: sampleCount * coverageUniformity */
+    effectiveSampleSize: number;
+    /** Recalculated confidence level using effective sample size */
+    adjustedLevel: 'low' | 'medium' | 'high';
+}
+/**
+ * Compute Normalized Shannon Entropy (Pielou's J) for distribution uniformity.
+ * Returns 1 for perfectly uniform, 0 for maximally concentrated.
+ *
+ * @param counts - Array of counts per group (e.g., evaluations per metric category)
+ * @returns Normalized Shannon entropy J in [0,1] where 1 = perfectly uniform
+ */
+export declare function computeNormalizedEntropy(counts: number[]): number;
+/**
+ * Compute coverage-weighted confidence.
+ * Adjusts confidence level based on evaluation distribution uniformity across inputs.
+ * A metric with 100 evaluations all from one session is less representative
+ * than 100 evaluations across 50 sessions.
+ *
+ * @param baseConfidence - Base confidence indicator from computeConfidence()
+ * @param evaluationsPerInput - Count of evaluations per input (session or trace)
+ * @returns Extended confidence with coverage weighting
+ */
+export declare function computeCoverageWeightedConfidence(baseConfidence: ConfidenceIndicator, evaluationsPerInput: number[]): CoverageWeightedConfidence;
+/**
+ * Variance ratio threshold for "increasing" trend detection.
+ * Research R5: shifted from 1.5x (~87% coverage, 13% FP) to 2.0 (~95% coverage, 5% FP).
+ * Aligns with Datadog 2-3 sigma default anomaly bounds.
+ */
+export declare const VARIANCE_INCREASE_THRESHOLD = 2;
+/**
+ * Variance decrease threshold. Ratios below this indicate decreasing variance.
+ * Mirrors VARIANCE_INCREASE_THRESHOLD: values significantly below 1.0 indicate
+ * the metric is converging (less noisy than baseline).
+ */
+export declare const VARIANCE_DECREASE_THRESHOLD = 0.7;
+/**
+ * Coverage dropout rate threshold. Rates above this are considered degraded.
+ * A 20% gap rate means 1 in 5 coverage cells is missing evaluations.
+ */
+export declare const COVERAGE_DROPOUT_THRESHOLD = 0.2;
+/** EWMA smoothing factor. lambda=0.1 catches slow drift; higher = more reactive. */
+export declare const EWMA_LAMBDA = 0.1;
+/** Quality degradation signal computed from leading indicators */
+export interface DegradationSignal {
+    /** Feature version for historical comparison validity */
+    featureVersion: string;
+    /** Variance trend direction */
+    varianceTrend: 'increasing' | 'stable' | 'decreasing';
+    /** Current stdDev / baseline stdDev ratio */
+    varianceRatio: number;
+    /** Coverage dropout rate (0-1) */
+    coverageDropoutRate: number;
+    /** Latency skew ratio (p95/p50) */
+    latencySkewRatio: number;
+    /** Predicted status based on feature combination */
+    predictedStatus: 'healthy' | 'warning' | 'critical';
+    /** EWMA drift signal: true when EWMA deviates from mean by > 2 * MAD */
+    ewmaDriftDetected: boolean;
+    /** Number of consecutive periods with active signals (for confirmation window) */
+    consecutiveBreaches: number;
+    /** Whether confirmation window is satisfied (>= 2 consecutive breaches) */
+    confirmed: boolean;
+}
+/**
+ * Compute EWMA (Exponentially Weighted Moving Average) from a time series.
+ * EWMA with lambda=0.1 catches slow quality drift that period-over-period deltas miss.
+ *
+ * @param values - Time-ordered score values (oldest first)
+ * @param lambda - Smoothing factor (0-1). Default: EWMA_LAMBDA (0.1)
+ * @returns Final EWMA value, or undefined if no values
+ */
+export declare function computeEWMA(values: number[], lambda?: number): number | undefined;
+/**
+ * Compute Median Absolute Deviation (MAD) for robust dispersion estimation.
+ * MAD is resistant to outliers unlike standard deviation.
+ * Scaled by 1.4826 for normal-equivalent consistency.
+ *
+ * @param values - Numeric values
+ * @returns Scaled MAD value, or 0 for insufficient data
+ */
+export declare function computeMAD(values: number[]): number;
+/**
+ * Detect EWMA drift by comparing the trailing EWMA to a baseline mean.
+ * The baseline is the first 70% of the series; drift is detected when the
+ * EWMA (which tracks recent values) deviates from the baseline by > k * MAD.
+ * When MAD = 0, falls back to range-based detection (> 10% of range).
+ */
+export declare function detectEWMADrift(values: number[], lambda?: number, k?: number): boolean;
+/** Options for degradation signal computation */
+export interface DegradationSignalOptions {
+    /** Historical score values for EWMA drift detection (oldest first) */
+    historicalValues?: number[];
+    /** Number of consecutive prior breaches (for confirmation window) */
+    priorConsecutiveBreaches?: number;
+}
+/**
+ * Compute degradation signal from current and baseline metrics.
+ *
+ * @param currentStdDev - Current period score standard deviation
+ * @param baselineStdDev - Baseline period score standard deviation
+ * @param coverageGapCount - Number of missing coverage cells
+ * @param totalCoverageCells - Total coverage cells expected
+ * @param latencyP95 - Evaluation latency p95 (optional)
+ * @param latencyP50 - Evaluation latency p50 (optional)
+ * @param options - Additional options for EWMA drift and confirmation windows
+ */
+export declare function computeDegradationSignal(currentStdDev: number | null, baselineStdDev: number | null, coverageGapCount: number, totalCoverageCells: number, latencyP95?: number | null, latencyP50?: number | null, options?: DegradationSignalOptions): DegradationSignal;
+/** Causal confidence level for correlation interpretations */
+export type CausalConfidence = 'correlation' | 'granger' | 'verified';
+/** Result of a bivariate Granger causality test */
+export interface GrangerResult {
+    /** F-statistic for the restricted vs unrestricted model comparison */
+    fStatistic: number;
+    /** P-value from the F-distribution */
+    pValue: number;
+    /** Number of lags used in the AR models */
+    lags: number;
+    /**
+     * Detected causal direction.
+     * A and B correspond to CorrelationFeature.metricA and metricB (alphabetically sorted).
+     */
+    direction: 'A->B' | 'B->A' | 'bidirectional' | 'none';
+}
+/** Data-driven correlation between two metrics */
+export interface CorrelationFeature {
+    featureVersion: string;
+    metricA: string;
+    metricB: string;
+    /** Pearson R correlation coefficient (-1 to 1) */
+    pearsonR: number;
+    /** Spearman rank correlation coefficient (-1 to 1). Better for bounded [0,1] scores. */
+    spearmanR: number;
+    /** Cohen's d effect size for the correlation (small: 0.2, medium: 0.5, large: 0.8) */
+    effectSize: number;
+    /** Time lag in hours where correlation is strongest */
+    lagHours: number;
+    /** Whether the correlation passed BH-FDR significance testing */
+    significant: boolean;
+    /** P-value from t-distribution for pearsonR */
+    pValue: number | null;
+    /** Causal confidence level (R3: correlation-only until Granger/verified) */
+    causalConfidence: CausalConfidence;
+    /** Fraction of periods where both are degraded simultaneously */
+    coOccurrenceRate: number;
+    /** Whether this pair matches a configured MetricCorrelationRule */
+    isKnownToxicCombo: boolean;
+    /** Granger causality test result (only when grangerConfig.enabled and sufficient data) */
+    granger?: GrangerResult;
+}
+/** Configuration for Granger causality testing */
+export interface GrangerConfig {
+    /** Enable Granger test on significant correlation pairs (default: false) */
+    enabled: boolean;
+    /** Minimum sample size for valid Granger test (default: 30) */
+    minSampleSize?: number;
+    /** Significance level for F-test (default: 0.05) */
+    significanceLevel?: number;
+}
+/** Options for correlation matrix computation */
+export interface CorrelationOptions {
+    /** Maximum lag steps to test (default: 0 = no lag detection) */
+    maxLagSteps?: number;
+    /** Hours per lag step (default: 1) */
+    lagStepHours?: number;
+    /** FDR q-value threshold for Benjamini-Hochberg (default: 0.05) */
+    fdrQ?: number;
+    /** Granger causality test configuration */
+    grangerConfig?: GrangerConfig;
+}
+/**
+ * Compute Pearson correlation coefficient between two numeric arrays.
+ * Returns 0 for insufficient data (< 3 points) or zero variance.
+ */
+export declare function computePearsonR(xs: number[], ys: number[]): number;
+/**
+ * Compute p-value for Pearson R using t-distribution approximation.
+ * t = r * sqrt((n-2) / (1-r^2)), two-tailed test.
+ * Uses the incomplete beta function approximation for t-distribution CDF.
+ */
+export declare function pearsonPValue(r: number, n: number): number | null;
+/**
+ * Apply Benjamini-Hochberg FDR correction to a set of p-values.
+ * Returns a boolean array indicating which hypotheses are significant.
+ *
+ * @param pValues - Array of p-values
+ * @param q - FDR threshold (default: 0.05)
+ * @returns Boolean array: true = significant at given FDR level
+ */
+export declare function benjaminiHochberg(pValues: number[], q?: number): boolean[];
+/**
+ * Compute Spearman rank correlation coefficient.
+ * Converts values to fractional ranks (average rank for ties) then computes Pearson R on ranks.
+ * Better than Pearson for bounded [0,1] quality scores that may have non-linear relationships.
+ */
+export declare function computeSpearmanR(xs: number[], ys: number[]): number;
+/**
+ * Compute Granger causality for a pair of time series.
+ * Tests both directions (A->B and B->A) using the best lag from correlation analysis.
+ *
+ * @param seriesA - Time-ordered scores for metric A
+ * @param seriesB - Time-ordered scores for metric B
+ * @param lags - Number of lags to use (from correlation lag detection, minimum 1)
+ * @param significanceLevel - P-value threshold (default: 0.05)
+ */
+export declare function computeGrangerCausality(seriesA: number[], seriesB: number[], lags: number, significanceLevel?: number): GrangerResult | undefined;
+/**
+ * Compute correlation matrix across all metric pairs.
+ * Supports time-lag detection and BH-FDR significance testing.
+ *
+ * Empty metric time series arrays are valid input and result in `pearsonR=0`
+ * for any pair involving that metric (insufficient data for correlation).
+ *
+ * @param metricTimeSeries - Map of metric name to time-ordered score arrays
+ * @param knownToxicCombos - Set of "metricA:metricB" pairs from correlation rules
+ * @param degradedPeriods - Map of metric name to boolean arrays (true = degraded in that period)
+ * @param options - Lag detection and significance testing options
+ * @example
+ * ```ts
+ * const series = new Map([
+ *   ['relevance', [0.9, 0.85, 0.88, 0.92]],
+ *   ['faithfulness', [0.8, 0.82, 0.79, 0.85]],
+ * ]);
+ * const correlations = computeCorrelationMatrix(series);
+ * // [{ metricA: 'faithfulness', metricB: 'relevance', pearsonR: 0.87, ... }]
+ * ```
+ */
+export declare function computeCorrelationMatrix(metricTimeSeries: Map<string, number[]>, knownToxicCombos?: Set<string>, degradedPeriods?: Map<string, boolean[]>, options?: CorrelationOptions): CorrelationFeature[];
+/**
+ * Compute percentile distribution from an array of numeric scores.
+ * Uses linear interpolation between adjacent sorted values.
+ *
+ * @param scores - Array of numeric scores (unsorted ok, will be sorted internally)
+ * @returns PercentileDistribution with p10/p25/p50/p75/p90, or undefined if < 3 scores
+ */
+export declare function computePercentileDistribution(scores: number[]): PercentileDistribution | undefined;
+/**
+ * Compute the percentile rank of a value within a sorted array.
+ * Returns the fraction of values in the array that are <= the given value (0-1).
+ *
+ * @param value - The value to rank
+ * @param sortedScores - Pre-sorted (ascending) array of scores
+ * @returns Percentile rank (0-1)
+ */
+export declare function computePercentileRank(value: number, sortedScores: number[]): number;
+/**
+ * Streaming percentile estimator backed by DDSketch.
+ * Wraps `@datadog/sketches-js` with a simplified API for quality pipeline use.
+ */
+export declare class StreamingPercentile {
+    private readonly sketch;
+    private totalCount;
+    constructor();
+    /** Add a single value to the sketch */
+    add(value: number): void;
+    /** Add multiple values at once */
+    addAll(values: number[]): void;
+    /** Get the current total count of observed values */
+    count(): number;
+    /** Estimate a percentile (0-100) from the sketch */
+    percentile(p: number): number;
+    /** Get full percentile distribution */
+    distribution(): PercentileDistribution | undefined;
+}
+/** Calibration state persisted between pipeline runs */
+export interface CalibrationState {
+    /** ISO timestamp of last calibration */
+    lastCalibrated: string;
+    /** Per-metric percentile distributions */
+    distributions: Record<string, {
+        distribution: PercentileDistribution;
+        sampleSize: number;
+        /** Window start (ISO date) */
+        windowStart: string;
+        /** Window end (ISO date) */
+        windowEnd: string;
+    }>;
+    /** PSI values from last recalibration check */
+    psiValues?: Record<string, number>;
+    /** Raw scores used to compute distributions (for PSI comparison on next run) */
+    rawScores?: Record<string, number[]>;
+}
+/** Population Stability Index result */
+export interface PSIResult {
+    psi: number;
+    /** true if PSI > PSI_RECALIBRATION_THRESHOLD (distribution has shifted) */
+    drifted: boolean;
+}
+/**
+ * Compute Population Stability Index (PSI) between two distributions.
+ * PSI measures distribution shift: < 0.1 = stable, 0.1–0.25 = moderate, > 0.25 = significant.
+ *
+ * Uses a `bins`-bin histogram comparison between expected (baseline) and actual (current).
+ * Returns { psi: 0, drifted: false } when either array has fewer than MIN_QUANTILE_SAMPLE_SIZE
+ * values (insufficient data for reliable estimation).
+ */
+export declare function computePSI(expected: number[], actual: number[], bins?: number): PSIResult;
+/**
+ * Determine whether calibration state should be rewritten based on PSI drift.
+ * Returns shouldWrite: true on first run (null previousState) or if any metric drifts.
+ */
+export declare function shouldRecalibrate(previousState: CalibrationState | null, currentScores: Record<string, number[]>): {
+    shouldWrite: boolean;
+    psiValues: Record<string, number>;
+};
+/**
+ * Compute calibration distributions from per-metric evaluation scores.
+ * Skips metrics with fewer than MIN_QUANTILE_SAMPLE_SIZE scores (unreliable percentiles).
+ * Uses StreamingPercentile to compute p10/p25/p50/p75/p90 for each qualifying metric.
+ * windowStart/windowEnd metadata reflects a CALIBRATION_WINDOW_DAYS rolling window,
+ * but the caller is responsible for pre-filtering scores to that window before passing them in.
+ */
+export declare function computeCalibrationDistributions(evaluationsByMetric: Record<string, number[]>): CalibrationState['distributions'];
+/**
+ * Load calibration state from persisted JSON file.
+ * Returns null if file does not exist or is malformed.
+ */
+export declare function loadCalibrationState(dir: string): CalibrationState | null;
+/**
+ * Save calibration state to JSON file for cross-run use by the dashboard API.
+ * Validates state before writing to ensure round-trip integrity.
+ */
+export declare function saveCalibrationState(dir: string, state: CalibrationState): void;
+/** Input data for the derived features pipeline */
+export interface DerivedFeaturesInput {
+    /** Quality metric results from dashboard summary (Step 2 output) */
+    metrics: QualityMetricResult[];
+    /** Per-metric time series for correlation computation */
+    metricTimeSeries?: Map<string, number[]>;
+    /** Evaluations per input for coverage-weighted confidence */
+    evaluationsPerInput?: Map<string, number[]>;
+    /** Degraded periods per metric for co-occurrence */
+    degradedPeriods?: Map<string, boolean[]>;
+    /** Known toxic combination keys ("metricA:metricB") */
+    knownToxicCombos?: Set<string>;
+    /** Optional custom CQI weights */
+    cqiWeights?: CQIWeights;
+    /** Correlation computation options */
+    correlationOptions?: CorrelationOptions;
+}
+/** Complete derived features output (Step 3 output) */
+export interface DerivedFeaturesResult {
+    /** Composite Quality Index */
+    cqi?: CompositeQualityIndex;
+    /** CQI sensitivity analysis */
+    cqiSensitivity?: CQISensitivity;
+    /** Per-metric coverage-weighted confidence */
+    coverageConfidence: Map<string, CoverageWeightedConfidence>;
+    /** Correlation matrix across metric pairs */
+    correlations: CorrelationFeature[];
+}
+/**
+ * Compute all derived features in correct dependency order.
+ *
+ * Pipeline ordering (QM2):
+ *   Step 2 (aggregate) outputs: metrics, CoverageHeatmap
+ *     ↓
+ *   Step 3a: CQI (depends on metrics)
+ *   Step 3b: Coverage-weighted confidence (depends on metrics + CoverageHeatmap via evaluationsPerInput)
+ *   Step 3c: Correlation matrix (depends on metricTimeSeries, independent of 3a/3b)
+ *
+ * CoverageHeatmap must be computed before calling this function.
+ * The evaluationsPerInput parameter is derived from CoverageHeatmap output.
+ *
+ * @param input - Aggregated data from Step 2
+ * @returns All derived features
+ */
+export declare function computeDerivedFeatures(input: DerivedFeaturesInput): DerivedFeaturesResult;
+/** A historical data point for backtesting the degradation detector */
+export interface BacktestSnapshot {
+    currentStdDev: number;
+    baselineStdDev: number;
+    coverageGapCount: number;
+    totalCoverageCells: number;
+    latencyP50?: number;
+    latencyP95?: number;
+    historicalValues?: number[];
+}
+/** Detector configuration for threshold sweep */
+export type BacktestConfig = z.infer<typeof backtestConfigSchema>;
+/** Labeled incident for backtest replay against historical time series */
+export interface LabeledIncident {
+    startTime: string;
+    endTime: string;
+    severity: 'minor' | 'major' | 'critical';
+}
+/** Parameter grid for sweepDegradationParams — all combinations are evaluated */
+export declare const BACKTEST_SWEEP: {
+    readonly varianceThreshold: readonly [1.5, 1.75, 2, 2.5, 3];
+    readonly coverageDropoutThreshold: readonly [0.1, 0.15, 0.2, 0.3, 0.4];
+    readonly ewmaLambda: readonly [0.05, 0.1, 0.15, 0.2, 0.3];
+    readonly confirmationWindow: readonly [1, 2, 3, 4];
+    readonly stabilityThreshold: readonly [0.005, 0.01, 0.02, 0.03, 0.05];
+};
+/** Current production detector configuration used as baseline in sweepDegradationParams */
+export declare const CURRENT_PRODUCTION_CONFIG: BacktestConfig;
+/** Result of a backtestDegradationConfig run with TaPR and point-based metrics */
+export type DegradationBacktestResult = z.infer<typeof degradationBacktestResultSchema>;
+/** Result of a sweepDegradationParams run with ranked TaPR metrics and baseline comparison */
+export type BacktestSweepResult = z.infer<typeof backtestSweepResultSchema>;
+/** Result of a single LOO fold in sweepWithCrossValidation */
+export interface CrossValidationFold {
+    /** The incident that was held out for this fold */
+    heldOutIncident: LabeledIncident;
+    /** Sweep result trained on the remaining incidents */
+    sweepResult: BacktestSweepResult;
+}
+/** Std dev of each BacktestConfig parameter across LOO folds */
+export interface ParameterStability {
+    varianceThresholdStdDev: number;
+    coverageDropoutThresholdStdDev: number;
+    confirmationWindowStdDev: number;
+}
+/** Result of sweepWithCrossValidation */
+export interface CrossValidationResult {
+    /** Full sweep on all incidents */
+    fullSweep: BacktestSweepResult;
+    /** One fold per held-out incident */
+    folds: CrossValidationFold[];
+    /** Std dev of best-F1 config parameters across folds (higher = less stable selection) */
+    parameterStability: ParameterStability;
+    /** True when every LOO fold selects the same best-by-F1 config as the full sweep */
+    isStable: boolean;
+}
+/**
+ * Inject synthetic degradation into baseline snapshots for testing.
+ * Returns a new array with degradation injected at the specified range.
+ *
+ * - variance_spike: sets currentStdDev = baselineStdDev * magnitude
+ * - coverage_gap: sets coverageGapCount = totalCoverageCells * magnitude (fraction)
+ * - latency_jump: sets latencyP95 = latencyP50 * magnitude (creates skew ratio = magnitude)
+ */
+export declare function injectDegradationScenario(snapshots: BacktestSnapshot[], type: 'variance_spike' | 'coverage_gap' | 'latency_jump', magnitude: number, startIdx: number, duration: number): BacktestSnapshot[];
+/** Zod schema for feature visibility configuration per role */
+export declare const roleFeatureConfigSchema: z.ZodObject<{
+    showCQI: z.ZodBoolean;
+    showCQIBreakdown: z.ZodBoolean;
+    showVariance: z.ZodBoolean;
+    showAcceleration: z.ZodBoolean;
+    showProjectedBreach: z.ZodBoolean;
+    showCorrelationRemediation: z.ZodBoolean;
+    showCoverageHeatmap: z.ZodBoolean;
+    showPipelineFunnel: z.ZodBoolean;
+    showProvenance: z.ZodBoolean;
+    showRawExport: z.ZodBoolean;
+    explanationTruncation: z.ZodNumber;
+    maxWorstEvaluations: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Get the feature configuration for a role.
+ */
+export declare function getRoleFeatureConfig(role: RoleType): z.infer<typeof roleFeatureConfigSchema>;
+/** Bridge between sync-to-kv bucket data and computeDegradationSignal() inputs */
+export interface RollingDegradationInput {
+    /** Metric name (matches QUALITY_METRICS key) */
+    metricName: string;
+    /** Standard deviation of scores in the current (most recent) bucket */
+    currentStdDev: number | null;
+    /** Standard deviation of scores in the baseline period (first 70% of buckets) */
+    baselineStdDev: number | null;
+    /** Number of time buckets with 0 evaluations (proxy for coverage gaps) */
+    bucketSparsityGaps: number;
+    /** Total number of time buckets in the window */
+    totalBuckets: number;
+    /** Bucket averages ordered oldest-first (for EWMA drift detection) */
+    historicalValues: number[];
+    /** Consecutive breach count from previous sync run */
+    priorConsecutiveBreaches: number;
+}
+/** Per-metric degradation report with full context */
+export interface DegradationReport {
+    /** Metric name (matches QUALITY_METRICS key) */
+    metricName: string;
+    /** Degradation signal from computeDegradationSignal() */
+    signal: DegradationSignal;
+    /**
+     * Trend from computeTrend() for the same window.
+     * Always null from computeRollingDegradationSignals — computeTrend() requires
+     * QualityMetricConfig (not available in the rolling signal context). Callers
+     * that have metric config should enrich this field after receiving the report.
+     */
+    trend: MetricTrend | null;
+    /** Window over which the signal was computed */
+    window: {
+        startDate: string;
+        endDate: string;
+    };
+    /** Baseline period used for stdDev comparison */
+    baselinePeriod: {
+        startDate: string;
+        endDate: string;
+    };
+    /** Total evaluation count across all buckets */
+    evaluationCount: number;
+}
+/** Persisted state for consecutive breach tracking across sync runs */
+export interface DegradationState {
+    /** ISO timestamp of last sync run that computed degradation signals */
+    lastRun: string;
+    /** metricName -> consecutive breach count from most recent computation */
+    breaches: Record<string, number>;
+}
+/**
+ * Compute sample standard deviation from an array of scores.
+ * Returns null for arrays with fewer than 2 values.
+ */
+export declare function computeStdDev(values: number[]): number | null;
+/**
+ * Load degradation state from persisted JSON file.
+ * Returns empty state if file does not exist or is malformed.
+ */
+export declare function loadDegradationState(dir: string): DegradationState;
+/**
+ * Save degradation state to JSON file for cross-run breach tracking.
+ * Validates state before writing to ensure round-trip integrity.
+ */
+export declare function saveDegradationState(dir: string, state: DegradationState): void;
+/**
+ * Compute degradation signals for all metrics from time-bucketed evaluation data.
+ *
+ * Bridges the gap between sync-to-kv's bucket structure and computeDegradationSignal()'s
+ * input requirements:
+ * - Computes stdDev inline from bucket scores (not available in computeAggregations)
+ * - Defines baseline as first DEGRADATION_BASELINE_RATIO (70%) of non-empty buckets
+ * - Uses bucket sparsity (buckets with 0 evals / total buckets) as coverage proxy
+ * - Passes latencyP95/P50 as null (latencySkewRatio defaults to 1.0)
+ * - Reads priorConsecutiveBreaches from persisted DegradationState
+ *
+ * Skips metrics with fewer than MIN_BUCKETS_FOR_SIGNAL (3) non-empty buckets.
+ */
+export declare function computeRollingDegradationSignals(timeBuckets: Record<string, Array<{
+    scores: number[];
+    startTime: string;
+    endTime: string;
+}>>, metricNames: string[], state: DegradationState, window: {
+    startDate: string;
+    endDate: string;
+}): DegradationReport[];
+export interface AHPComparison {
+    metricA: string;
+    metricB: string;
+    preference: 1 | 3 | 5 | 7 | 9;
+    preferred: 'A' | 'B';
+}
+export interface CRITICWeights {
+    weights: Record<string, number>;
+    informationContent: Record<string, number>;
+}
+export interface QualityIncident {
+    timestamp: string;
+    metricScores: Record<string, number>;
+    cqiValue: number;
+    severity: 'minor' | 'major' | 'critical';
+}
+export interface TunedCQIWeights {
+    featureVersion: string;
+    weights: Record<string, number>;
+    ahpWeights: Record<string, number>;
+    criticWeights: Record<string, number>;
+    alpha: number;
+    consistencyRatio: number;
+    incidentCorrelations: Record<string, number>;
+}
+export declare function computeAHPWeights(comparisons: AHPComparison[], metrics: string[]): {
+    weights: Record<string, number>;
+    consistencyRatio: number;
+};
+export declare function computeCRITICWeights(metricScoreHistory: Record<string, number[]>): CRITICWeights;
+export declare function computeHybridCQIWeights(ahpWeights: Record<string, number>, criticWeights: Record<string, number>, incidents: QualityIncident[], metrics: string[], alpha?: number): TunedCQIWeights;
+export type TaPRMetrics = z.infer<typeof taprMetricsSchema>;
+export declare function computeTaPR(detectedRanges: Array<{
+    start: number;
+    end: number;
+}>, incidentRanges: Array<{
+    start: number;
+    end: number;
+}>): TaPRMetrics;
+type BacktestTimeSeriesPoint = {
+    timestamp: number;
+    currentStdDev: number;
+    baselineStdDev: number;
+    coverageGapCount: number;
+    totalCoverageCells: number;
+    latencyP95: number;
+    latencyP50: number;
+    historicalValues: number[];
+};
+/**
+ * Runs a degradation signal backtest with a specific parameter configuration.
+ * Replays historical time series data and compares detected degradation periods
+ * against labeled incidents using TaPR and point-based metrics.
+ */
+export declare function backtestDegradationConfig(config: BacktestConfig, timeSeries: BacktestTimeSeriesPoint[], incidents: LabeledIncident[]): DegradationBacktestResult;
+/**
+ * Runs a full parameter sweep across the BACKTEST_SWEEP grid, ranks results by TaPR F1,
+ * and includes the current production config as a baseline comparison.
+ */
+export declare function sweepDegradationParams(timeSeries: BacktestTimeSeriesPoint[], incidents: LabeledIncident[]): BacktestSweepResult;
+/**
+ * Leave-one-out cross-validation for sweepDegradationParams.
+ *
+ * With only 5-10 incidents, overfitting risk is high. This function holds out
+ * each incident in turn, runs the full sweep on the remaining incidents, and
+ * reports variance in the optimal config selection across folds.
+ *
+ * High parameterVariance values indicate that the best config is sensitive to
+ * individual incidents and should not be trusted for threshold graduation.
+ */
+export declare function sweepWithCrossValidation(timeSeries: BacktestTimeSeriesPoint[], incidents: LabeledIncident[]): CrossValidationResult;
+export {};
+//# sourceMappingURL=quality-feature-engineering.d.ts.map