observability-toolkit 1.8.5 → 2.1.0

package/dist/lib/quality/quality-metrics.d.ts

@@ -0,0 +1,943 @@
+/**
+ * Quality Metrics Dashboard Helpers
+ *
+ * Pre-defined evaluation metrics with alerting thresholds for LLM quality monitoring.
+ * Designed for dashboard integration with observability platforms (SigNoz, Grafana, etc.).
+ *
+ * @see BACKLOG.md Quality Metrics Dashboard section
+ * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-events/
+ */
+import { z } from 'zod';
+import type { EvaluationResult } from '../../backends/index.js';
+import { type EvaluationAggregation, type TimeRange } from '../core/shared-schemas.js';
+import { type QualityMetricName } from './quality-constants.js';
+export { roleTypeSchema, type RoleType, qualityMetricNameSchema, type QualityMetricName, cqiWeightsSchema, type CQIWeights, TREND_MIN_SAMPLE_SIZE, DEFAULT_BIN_COUNT, DEFAULT_ENTROPY_THRESHOLD } from './quality-constants.js';
+/** Recognized SLA window formats */
+export declare const slaWindowFormatSchema: z.ZodEnum<{
+    "7d rolling": "7d rolling";
+    "14d rolling": "14d rolling";
+    "30d rolling": "30d rolling";
+    "60d rolling": "60d rolling";
+    "90d rolling": "90d rolling";
+    "calendar day": "calendar day";
+    "calendar week": "calendar week";
+    "calendar month": "calendar month";
+    "calendar quarter": "calendar quarter";
+    "calendar year": "calendar year";
+}>;
+export type SLAWindowFormat = z.infer<typeof slaWindowFormatSchema>;
+/** All possible SLA evaluation statuses */
+export declare const slaStatusSchema: z.ZodEnum<{
+    compliant: "compliant";
+    non_compliant: "non_compliant";
+    no_data: "no_data";
+    metric_not_found: "metric_not_found";
+}>;
+/** SLA evaluation status distinguishing compliance failures from missing data */
+export type SLAStatus = z.infer<typeof slaStatusSchema>;
+/**
+ * Pre-defined quality metrics with recommended thresholds.
+ * Based on industry best practices for LLM evaluation.
+ */
+export declare const QUALITY_METRICS: Record<QualityMetricName, QualityMetricConfig>;
+export declare const alertSeveritySchema: z.ZodEnum<{
+    info: "info";
+    warning: "warning";
+    critical: "critical";
+}>;
+declare const thresholdDirectionSchema: z.ZodEnum<{
+    above: "above";
+    below: "below";
+}>;
+export declare const healthStatusSchema: z.ZodEnum<{
+    warning: "warning";
+    critical: "critical";
+    healthy: "healthy";
+    no_data: "no_data";
+}>;
+declare const valueAlertSchema: z.ZodObject<{
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    value: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+declare const divergenceAlertSchema: z.ZodObject<{
+    type: z.ZodLiteral<"divergence">;
+    entropyThreshold: z.ZodNumber;
+    bins: z.ZodInt;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+declare const alertThresholdUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"divergence">;
+    entropyThreshold: z.ZodNumber;
+    bins: z.ZodInt;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    value: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>]>;
+export declare const divergenceDetailsSchema: z.ZodObject<{
+    entropy: z.ZodNumber;
+    entropyThreshold: z.ZodNumber;
+    bins: z.ZodInt;
+    histogram: z.ZodArray<z.ZodInt>;
+}, z.core.$strip>;
+export declare const severityContextSchema: z.ZodObject<{
+    environment: z.ZodOptional<z.ZodString>;
+    escalateWarnings: z.ZodOptional<z.ZodBoolean>;
+    suppressInfo: z.ZodOptional<z.ZodBoolean>;
+    minSampleCount: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+export declare const metricTrendSchema: z.ZodObject<{
+    direction: z.ZodEnum<{
+        improving: "improving";
+        degrading: "degrading";
+        stable: "stable";
+    }>;
+    delta: z.ZodNumber;
+    percentChange: z.ZodNullable<z.ZodNumber>;
+    previousValue: z.ZodNumber;
+    currentValue: z.ZodNumber;
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    lowSampleWarning: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const confidenceIndicatorSchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    sampleCount: z.ZodInt;
+    scoreStdDev: z.ZodNullable<z.ZodNumber>;
+    evaluatorCount: z.ZodInt;
+    evaluatorAgreement: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const worstExplanationSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    explanation: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const triggeredAlertSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    threshold: z.ZodNumber;
+    actualValue: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    affectedCount: z.ZodOptional<z.ZodInt>;
+    remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relatedMetrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    isCompound: z.ZodOptional<z.ZodBoolean>;
+    divergenceDetails: z.ZodOptional<z.ZodObject<{
+        entropy: z.ZodNumber;
+        entropyThreshold: z.ZodNumber;
+        bins: z.ZodInt;
+        histogram: z.ZodArray<z.ZodInt>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const qualityMetricResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    values: z.ZodRecord<z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>, z.ZodNullable<z.ZodNumber>>;
+    sampleCount: z.ZodInt;
+    alerts: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            critical: "critical";
+        }>;
+        message: z.ZodString;
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        threshold: z.ZodNumber;
+        actualValue: z.ZodNumber;
+        direction: z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>;
+        affectedCount: z.ZodOptional<z.ZodInt>;
+        remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        relatedMetrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        isCompound: z.ZodOptional<z.ZodBoolean>;
+        divergenceDetails: z.ZodOptional<z.ZodObject<{
+            entropy: z.ZodNumber;
+            entropyThreshold: z.ZodNumber;
+            bins: z.ZodInt;
+            histogram: z.ZodArray<z.ZodInt>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        warning: "warning";
+        critical: "critical";
+        healthy: "healthy";
+        no_data: "no_data";
+    }>;
+    period: z.ZodOptional<z.ZodObject<{
+        start: z.ZodISODateTime;
+        end: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    worstExplanation: z.ZodOptional<z.ZodObject<{
+        score: z.ZodNumber;
+        explanation: z.ZodOptional<z.ZodString>;
+        traceId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    trend: z.ZodOptional<z.ZodObject<{
+        direction: z.ZodEnum<{
+            improving: "improving";
+            degrading: "degrading";
+            stable: "stable";
+        }>;
+        delta: z.ZodNumber;
+        percentChange: z.ZodNullable<z.ZodNumber>;
+        previousValue: z.ZodNumber;
+        currentValue: z.ZodNumber;
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        lowSampleWarning: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    confidence: z.ZodOptional<z.ZodObject<{
+        level: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        sampleCount: z.ZodInt;
+        scoreStdDev: z.ZodNullable<z.ZodNumber>;
+        evaluatorCount: z.ZodInt;
+        evaluatorAgreement: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const qualityMetricConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    aggregations: z.ZodArray<z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>>;
+    alerts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"divergence">;
+        entropyThreshold: z.ZodNumber;
+        bins: z.ZodInt;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            critical: "critical";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        value: z.ZodNumber;
+        direction: z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            critical: "critical";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>]>>;
+    range: z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>;
+    unit: z.ZodEnum<{
+        rate: "rate";
+        score: "score";
+        percentage: "percentage";
+        seconds: "seconds";
+    }>;
+    remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const metricConditionSchema: z.ZodObject<{
+    metric: z.ZodString;
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    value: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    window: z.ZodOptional<z.ZodEnum<{
+        "7d rolling": "7d rolling";
+        "14d rolling": "14d rolling";
+        "30d rolling": "30d rolling";
+        "60d rolling": "60d rolling";
+        "90d rolling": "90d rolling";
+        "calendar day": "calendar day";
+        "calendar week": "calendar week";
+        "calendar month": "calendar month";
+        "calendar quarter": "calendar quarter";
+        "calendar year": "calendar year";
+    }>>;
+    sustainedPeriods: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+export declare const metricCorrelationRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodString;
+    conditions: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        value: z.ZodNumber;
+        direction: z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>;
+        window: z.ZodOptional<z.ZodEnum<{
+            "7d rolling": "7d rolling";
+            "14d rolling": "14d rolling";
+            "30d rolling": "30d rolling";
+            "60d rolling": "60d rolling";
+            "90d rolling": "90d rolling";
+            "calendar day": "calendar day";
+            "calendar week": "calendar week";
+            "calendar month": "calendar month";
+            "calendar quarter": "calendar quarter";
+            "calendar year": "calendar year";
+        }>>;
+        sustainedPeriods: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    explanation: z.ZodString;
+}, z.core.$strip>;
+export declare const slaDefinitionSchema: z.ZodObject<{
+    metric: z.ZodString;
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    target: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    window: z.ZodOptional<z.ZodEnum<{
+        "7d rolling": "7d rolling";
+        "14d rolling": "14d rolling";
+        "30d rolling": "30d rolling";
+        "60d rolling": "60d rolling";
+        "90d rolling": "90d rolling";
+        "calendar day": "calendar day";
+        "calendar week": "calendar week";
+        "calendar month": "calendar month";
+        "calendar quarter": "calendar quarter";
+        "calendar year": "calendar year";
+    }>>;
+}, z.core.$strip>;
+export declare const slaComplianceResultSchema: z.ZodObject<{
+    sla: z.ZodObject<{
+        metric: z.ZodString;
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        target: z.ZodNumber;
+        direction: z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>;
+        window: z.ZodOptional<z.ZodEnum<{
+            "7d rolling": "7d rolling";
+            "14d rolling": "14d rolling";
+            "30d rolling": "30d rolling";
+            "60d rolling": "60d rolling";
+            "90d rolling": "90d rolling";
+            "calendar day": "calendar day";
+            "calendar week": "calendar week";
+            "calendar month": "calendar month";
+            "calendar quarter": "calendar quarter";
+            "calendar year": "calendar year";
+        }>>;
+    }, z.core.$strip>;
+    compliant: z.ZodBoolean;
+    status: z.ZodEnum<{
+        compliant: "compliant";
+        non_compliant: "non_compliant";
+        no_data: "no_data";
+        metric_not_found: "metric_not_found";
+    }>;
+    actualValue: z.ZodNullable<z.ZodNumber>;
+    gap: z.ZodNullable<z.ZodNumber>;
+    marginPercent: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+/** TriggeredAlert with its source metric name — used in dashboard alerts and view schemas. */
+export declare const alertWithMetricSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        critical: "critical";
+    }>;
+    message: z.ZodString;
+    aggregation: z.ZodEnum<{
+        avg: "avg";
+        min: "min";
+        max: "max";
+        count: "count";
+        p50: "p50";
+        p95: "p95";
+        p99: "p99";
+    }>;
+    threshold: z.ZodNumber;
+    actualValue: z.ZodNumber;
+    direction: z.ZodEnum<{
+        above: "above";
+        below: "below";
+    }>;
+    affectedCount: z.ZodOptional<z.ZodInt>;
+    remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relatedMetrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    isCompound: z.ZodOptional<z.ZodBoolean>;
+    divergenceDetails: z.ZodOptional<z.ZodObject<{
+        entropy: z.ZodNumber;
+        entropyThreshold: z.ZodNumber;
+        bins: z.ZodInt;
+        histogram: z.ZodArray<z.ZodInt>;
+    }, z.core.$strip>>;
+    metricName: z.ZodString;
+}, z.core.$strip>;
+/** Per-metric count breakdown shown in ExecutiveView summary. */
+export declare const dashboardSummaryStatsSchema: z.ZodObject<{
+    totalMetrics: z.ZodInt;
+    healthyMetrics: z.ZodInt;
+    warningMetrics: z.ZodInt;
+    criticalMetrics: z.ZodInt;
+    noDataMetrics: z.ZodInt;
+}, z.core.$strip>;
+export declare const qualityDashboardSummarySchema: z.ZodObject<{
+    overallStatus: z.ZodEnum<{
+        warning: "warning";
+        critical: "critical";
+        healthy: "healthy";
+        no_data: "no_data";
+    }>;
+    metrics: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodString;
+        values: z.ZodRecord<z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>, z.ZodNullable<z.ZodNumber>>;
+        sampleCount: z.ZodInt;
+        alerts: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+                critical: "critical";
+            }>;
+            message: z.ZodString;
+            aggregation: z.ZodEnum<{
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count: "count";
+                p50: "p50";
+                p95: "p95";
+                p99: "p99";
+            }>;
+            threshold: z.ZodNumber;
+            actualValue: z.ZodNumber;
+            direction: z.ZodEnum<{
+                above: "above";
+                below: "below";
+            }>;
+            affectedCount: z.ZodOptional<z.ZodInt>;
+            remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            relatedMetrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            isCompound: z.ZodOptional<z.ZodBoolean>;
+            divergenceDetails: z.ZodOptional<z.ZodObject<{
+                entropy: z.ZodNumber;
+                entropyThreshold: z.ZodNumber;
+                bins: z.ZodInt;
+                histogram: z.ZodArray<z.ZodInt>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            warning: "warning";
+            critical: "critical";
+            healthy: "healthy";
+            no_data: "no_data";
+        }>;
+        period: z.ZodOptional<z.ZodObject<{
+            start: z.ZodISODateTime;
+            end: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        worstExplanation: z.ZodOptional<z.ZodObject<{
+            score: z.ZodNumber;
+            explanation: z.ZodOptional<z.ZodString>;
+            traceId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        trend: z.ZodOptional<z.ZodObject<{
+            direction: z.ZodEnum<{
+                improving: "improving";
+                degrading: "degrading";
+                stable: "stable";
+            }>;
+            delta: z.ZodNumber;
+            percentChange: z.ZodNullable<z.ZodNumber>;
+            previousValue: z.ZodNumber;
+            currentValue: z.ZodNumber;
+            aggregation: z.ZodEnum<{
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count: "count";
+                p50: "p50";
+                p95: "p95";
+                p99: "p99";
+            }>;
+            lowSampleWarning: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        confidence: z.ZodOptional<z.ZodObject<{
+            level: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            sampleCount: z.ZodInt;
+            scoreStdDev: z.ZodNullable<z.ZodNumber>;
+            evaluatorCount: z.ZodInt;
+            evaluatorAgreement: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    alerts: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            critical: "critical";
+        }>;
+        message: z.ZodString;
+        aggregation: z.ZodEnum<{
+            avg: "avg";
+            min: "min";
+            max: "max";
+            count: "count";
+            p50: "p50";
+            p95: "p95";
+            p99: "p99";
+        }>;
+        threshold: z.ZodNumber;
+        actualValue: z.ZodNumber;
+        direction: z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>;
+        affectedCount: z.ZodOptional<z.ZodInt>;
+        remediationHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        relatedMetrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        isCompound: z.ZodOptional<z.ZodBoolean>;
+        divergenceDetails: z.ZodOptional<z.ZodObject<{
+            entropy: z.ZodNumber;
+            entropyThreshold: z.ZodNumber;
+            bins: z.ZodInt;
+            histogram: z.ZodArray<z.ZodInt>;
+        }, z.core.$strip>>;
+        metricName: z.ZodString;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        totalMetrics: z.ZodInt;
+        healthyMetrics: z.ZodInt;
+        warningMetrics: z.ZodInt;
+        criticalMetrics: z.ZodInt;
+        noDataMetrics: z.ZodInt;
+    }, z.core.$strip>;
+    slaCompliance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sla: z.ZodObject<{
+            metric: z.ZodString;
+            aggregation: z.ZodEnum<{
+                avg: "avg";
+                min: "min";
+                max: "max";
+                count: "count";
+                p50: "p50";
+                p95: "p95";
+                p99: "p99";
+            }>;
+            target: z.ZodNumber;
+            direction: z.ZodEnum<{
+                above: "above";
+                below: "below";
+            }>;
+            window: z.ZodOptional<z.ZodEnum<{
+                "7d rolling": "7d rolling";
+                "14d rolling": "14d rolling";
+                "30d rolling": "30d rolling";
+                "60d rolling": "60d rolling";
+                "90d rolling": "90d rolling";
+                "calendar day": "calendar day";
+                "calendar week": "calendar week";
+                "calendar month": "calendar month";
+                "calendar quarter": "calendar quarter";
+                "calendar year": "calendar year";
+            }>>;
+        }, z.core.$strip>;
+        compliant: z.ZodBoolean;
+        status: z.ZodEnum<{
+            compliant: "compliant";
+            non_compliant: "non_compliant";
+            no_data: "no_data";
+            metric_not_found: "metric_not_found";
+        }>;
+        actualValue: z.ZodNullable<z.ZodNumber>;
+        gap: z.ZodNullable<z.ZodNumber>;
+        marginPercent: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+/** Alert severity levels for quality metrics */
+export type AlertSeverity = z.infer<typeof alertSeveritySchema>;
+/** Alert condition direction */
+export type ThresholdDirection = z.infer<typeof thresholdDirectionSchema>;
+/** Alert threshold configuration (value-based) */
+export type AlertThreshold = z.infer<typeof valueAlertSchema>;
+/** Divergence alert: fires when score distribution entropy drops below threshold */
+export type DivergenceAlertThreshold = z.infer<typeof divergenceAlertSchema>;
+/** Unified alert threshold (discriminated union) */
+export type AlertThresholdUnion = z.infer<typeof alertThresholdUnionSchema>;
+/** Metric configuration for dashboard display */
+export type QualityMetricConfig = z.infer<typeof qualityMetricConfigSchema>;
+/** Direction of a metric trend over time */
+export type TrendDirection = 'improving' | 'degrading' | 'stable';
+/** Details about a triggered divergence alert */
+export type DivergenceDetails = z.infer<typeof divergenceDetailsSchema>;
+/** Contextual severity override for environment-aware alerting */
+export type SeverityContext = z.infer<typeof severityContextSchema>;
+/** Metric trend computed by comparing current period to a previous period */
+export type MetricTrend = z.infer<typeof metricTrendSchema>;
+/** Confidence indicator for a metric based on sample size and evaluator agreement */
+export type ConfidenceIndicator = z.infer<typeof confidenceIndicatorSchema>;
+/** Worst-performing evaluation explanation for alert drill-down */
+export type WorstExplanation = z.infer<typeof worstExplanationSchema>;
+/** Alert that has been triggered */
+export type TriggeredAlert = z.infer<typeof triggeredAlertSchema>;
+/** Computed metric result with alert status */
+export type QualityMetricResult = z.infer<typeof qualityMetricResultSchema>;
+/** A condition within a correlation rule */
+export type MetricCondition = z.infer<typeof metricConditionSchema>;
+/** Cross-metric correlation rule that detects compound risk patterns */
+export type MetricCorrelationRule = z.infer<typeof metricCorrelationRuleSchema>;
+/** SLA definition for a quality metric */
+export type SLADefinition = z.infer<typeof slaDefinitionSchema>;
+/** SLA compliance result for a single metric */
+export type SLAComplianceResult = z.infer<typeof slaComplianceResultSchema>;
+/** Dashboard summary across all metrics */
+export type QualityDashboardSummary = z.infer<typeof qualityDashboardSummarySchema>;
+/** @internal Decimal precision for score values (e.g., 0.8500) */
+export declare const SCORE_PRECISION = 4;
+/** @internal Decimal precision for percentage values (e.g., 12.50%) */
+export declare const PERCENT_PRECISION = 2;
+/** @internal Round a number to the given decimal places */
+export declare function roundTo(value: number, decimals: number): number;
+/** @internal Sort alerts by severity (critical first, then warning, then info). Returns new array. */
+export declare function sortAlertsBySeverity<T extends {
+    severity: AlertSeverity;
+}>(alerts: T[]): T[];
+/**
+ * Compute aggregations for a set of evaluation scores.
+ * @param scores - Array of score values
+ * @param aggregations - Aggregations to compute
+ */
+export declare function computeAggregations(scores: number[], aggregations: EvaluationAggregation[]): Record<EvaluationAggregation, number | null>;
+/**
+ * Check a divergence alert threshold against raw scores.
+ * Returns a triggered alert if the score distribution entropy is below the threshold,
+ * or null if entropy is acceptable or there are insufficient samples.
+ *
+ * @param scores - Raw score values
+ * @param threshold - Divergence alert threshold configuration
+ */
+export declare function checkDivergenceAlert(scores: number[], threshold: DivergenceAlertThreshold): TriggeredAlert | null;
+/**
+ * Check alert thresholds and return triggered alerts.
+ * Supports both value-based (AlertThreshold) and divergence-based (DivergenceAlertThreshold) alerts.
+ *
+ * @param values - Computed aggregation values
+ * @param thresholds - Alert thresholds to check (value and/or divergence)
+ * @param options - Optional enrichment data; `scores` required for divergence alerts
+ */
+export declare function checkAlertThresholds(values: Record<EvaluationAggregation, number | null>, thresholds: AlertThresholdUnion[], options?: {
+    sampleCount?: number;
+    remediationHints?: string[];
+    scores?: number[];
+}): TriggeredAlert[];
+/**
+ * Determine overall health status from triggered alerts.
+ */
+export declare function determineHealthStatus(alerts: TriggeredAlert[], hasData: boolean): 'healthy' | 'warning' | 'critical' | 'no_data';
+/**
+ * Compute a single quality metric from evaluation results.
+ * @param evaluations - Evaluation results filtered by metric name
+ * @param config - Metric configuration
+ * @param period - Optional time period
+ * @param previousValues - Optional previous period aggregation values for trend computation
+ */
+export declare function computeQualityMetric(evaluations: EvaluationResult[], config: QualityMetricConfig, period?: TimeRange, previousValues?: Record<EvaluationAggregation, number | null>): QualityMetricResult;
+/**
+ * Compute dashboard summary for all quality metrics.
+ * @param evaluationsByMetric - Map of metric name to evaluation results
+ * @param customMetrics - Optional custom metric configurations to include
+ * @param period - Optional time period
+ * @param slas - Optional SLA definitions to evaluate
+ * @param previousPeriodValues - Optional previous period aggregation values per metric for trend computation
+ */
+export declare function computeDashboardSummary(evaluationsByMetric: Map<string, EvaluationResult[]>, customMetrics?: Record<string, QualityMetricConfig>, period?: TimeRange, slas?: SLADefinition[], previousPeriodValues?: Map<string, Record<EvaluationAggregation, number | null>>): QualityDashboardSummary;
+/**
+ * Register a custom quality metric.
+ * @param config - Metric configuration
+ * @throws If metric with same name already exists
+ */
+export declare function registerQualityMetric(config: QualityMetricConfig): void;
+/**
+ * Check if a quality metric exists (built-in or custom).
+ * @param name - Metric name
+ * @returns true if metric exists
+ */
+export declare function hasQualityMetric(name: string): boolean;
+/**
+ * Unregister a custom quality metric.
+ * @param name - Metric name
+ * @returns true if metric was removed
+ */
+export declare function unregisterQualityMetric(name: string): boolean;
+/**
+ * Get all registered quality metrics (built-in + custom).
+ * @returns Combined record of built-in and custom metric configs
+ */
+export declare function getAllQualityMetrics(): Record<string, QualityMetricConfig>;
+/**
+ * Get a specific quality metric configuration.
+ * @param name - Metric name
+ * @returns Metric config if found, undefined otherwise
+ */
+export declare function getQualityMetric(name: string): QualityMetricConfig | undefined;
+/**
+ * Clear all custom metrics (for testing).
+ * @internal
+ */
+export declare function clearCustomMetrics(): void;
+/** Immutable default correlation rules. */
+export declare const DEFAULT_CORRELATION_RULES: readonly MetricCorrelationRule[];
+/**
+ * Register a correlation rule.
+ * @throws If rule with same name exists or validation fails
+ */
+export declare function registerCorrelationRule(rule: MetricCorrelationRule): void;
+/**
+ * Unregister a custom correlation rule.
+ */
+export declare function unregisterCorrelationRule(name: string): boolean;
+/**
+ * Get all correlation rules (defaults + custom).
+ */
+export declare function getCorrelationRules(): MetricCorrelationRule[];
+/**
+ * Clear all custom correlation rules (for testing).
+ * @internal
+ */
+export declare function clearCorrelationRules(): void;
+/**
+ * Evaluate correlation rules against computed metric results.
+ * Returns compound alerts for rules where all conditions match.
+ *
+ * When `previousResults` is provided, conditions with temporal fields are evaluated:
+ * - `window`: condition checks the metric value from the previous-period result whose
+ *   window label matches the condition's window (falls back to current results).
+ * - `sustainedPeriods`: condition must hold in N consecutive previous result sets
+ *   (most recent first). If fewer than N periods are available, the condition is not met.
+ *
+ * @param results - Current period metric results
+ * @param rules - Correlation rules to evaluate
+ * @param previousResults - Optional ordered array of previous-period results (most recent first).
+ *   Each entry is tagged with a `window` label indicating its time range.
+ */
+export declare function evaluateCorrelationRules(results: QualityMetricResult[], rules: readonly MetricCorrelationRule[], previousResults?: Array<{
+    window: SLAWindowFormat;
+    results: QualityMetricResult[];
+}>): Array<TriggeredAlert & {
+    metricName: string;
+}>;
+export { evaluateHandoffs, computeTurnLevelResults, computeMultiAgentEvaluation } from './quality-multi-agent.js';
+export type { HandoffEvaluation, TurnLevelResult, MultiAgentEvaluation, HandoffThresholds } from './quality-multi-agent.js';
+export { computeRoleView, computeMetricDetail, toEvaluationDetail, scoreDistributionEntrySchema, evaluationSnapshotSchema, metricDetailFieldsSchema, evaluationDetailResultSchema, roleViewOptionsSchema } from './quality-views.js';
+export type { ExecutiveView, OperatorView, AuditorView, RoleView, RoleViewOptions, MetricDetailResult, EvaluationDetailResult, MetricDetailOptions } from './quality-views.js';
+export { applySeverityContext } from './quality-alerts.js';
+export { evaluateSLA, evaluateSLAs } from './quality-sla.js';
+export type { SLAEvaluationResult } from './quality-sla.js';
+export { computeConfidence, computeTrend } from './quality-trends.js';
+export type { ConfidenceThresholds } from './quality-trends.js';
+export { computePipelineView, computeCoverageHeatmap } from './quality-visualization.js';
+export type { PipelineStage, PipelineDropoff, PipelineResult, CoverageStatus, CoverageCell, CoverageGap, CoverageHeatmap, CoverageHeatmapOptions } from './quality-visualization.js';
+export { scoreColorBand, adaptiveScoreColorBand, empiricalCDF, inferScoreDirection, labelToOrdinal, ordinalToCategory, computeCQI, computeCQISensitivity, DEFAULT_CQI_WEIGHTS, computeMetricDynamics, computeCoverageWeightedConfidence, computeNormalizedEntropy, computeDegradationSignal, computeEWMA, computeMAD, detectEWMADrift, VARIANCE_INCREASE_THRESHOLD, EWMA_LAMBDA, computePearsonR, computeSpearmanR, computeCorrelationMatrix, pearsonPValue, benjaminiHochberg, getRoleFeatureConfig, roleFeatureConfigSchema, METRIC_SCALE_STRATEGY, } from './quality-feature-engineering.js';
+export type { ScoreDirection, ScaleStrategy, ScoreColorBand, PercentileDistribution, LabelFilterCategory, LabelOrdinal, CQIContribution, CompositeQualityIndex, CQISensitivity, CQISensitivityEntry, MetricDynamics, CoverageWeightedConfidence, DegradationSignal, DegradationSignalOptions, CorrelationFeature, CorrelationOptions, CausalConfidence, } from './quality-feature-engineering.js';
+/**
+ * Format metric value for display.
+ * @param value - Numeric value
+ * @param unit - Unit type
+ * @returns Formatted string (e.g., "85.0%", "1.23s", "0.8500")
+ */
+export declare function formatMetricValue(value: number | null, unit: QualityMetricConfig['unit']): string;
+/**
+ * Create a custom metric configuration builder.
+ * @param name - Metric name
+ * @returns Fluent builder for constructing QualityMetricConfig
+ */
+export declare function createMetricConfig(name: string): MetricConfigBuilder;
+/**
+ * Fluent builder for QualityMetricConfig.
+ */
+export declare class MetricConfigBuilder {
+    private config;
+    constructor(name: string);
+    displayName(name: string): this;
+    description(desc: string): this;
+    aggregations(...aggs: EvaluationAggregation[]): this;
+    range(min: number, max: number): this;
+    unit(unit: QualityMetricConfig['unit']): this;
+    alertBelow(aggregation: EvaluationAggregation, value: number, severity: AlertSeverity, message?: string): this;
+    remediationHints(...hints: string[]): this;
+    alertAbove(aggregation: EvaluationAggregation, value: number, severity: AlertSeverity, message?: string): this;
+    divergenceAlert(entropyThreshold: number, severity: AlertSeverity, message?: string, bins?: number): this;
+    sla(aggregation: EvaluationAggregation, target: number, direction?: ThresholdDirection, window?: SLAWindowFormat): SLADefinition;
+    build(): QualityMetricConfig;
+}
+//# sourceMappingURL=quality-metrics.d.ts.map