@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.530

package/dist/productionReadiness.d.ts

@@ -0,0 +1,756 @@
+import { Elysia } from "elysia";
+import { type VoiceProviderFallbackRecoverySummary } from "./sessionReplay";
+import { type VoiceTelephonyCarrierMatrixInput } from "./telephony/matrix";
+import { type VoiceTelephonyWebhookSecurityOptions, type VoiceTelephonyWebhookSecurityReport } from "./telephony/security";
+import type { VoiceMonitorNotifierDeliveryReport, VoiceMonitorRunReport } from "./voiceMonitoring";
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from "./trace";
+import type { VoiceTraceSinkDeliveryStore } from "./trace";
+import type { VoiceAgentSquadContractReport } from "./agentSquadContract";
+import type { VoiceBargeInReport } from "./bargeInRoutes";
+import type { VoiceDeliveryRuntime, VoiceDeliveryRuntimeSummary } from "./deliveryRuntime";
+import type { VoiceProviderRoutingContractReport } from "./providerRoutingContract";
+import type { VoicePhoneAgentProductionSmokeReport } from "./phoneAgentProductionSmoke";
+import type { VoiceReconnectContractReport, VoiceReconnectProofReport } from "./reconnectContract";
+import type { VoiceAuditEventStore, VoiceAuditEventType, VoiceAuditOutcome } from "./audit";
+import { type VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { VoiceProviderContractMatrixReport, VoiceProviderStackCapabilityGapReport } from "./providerStackRecommendations";
+import { type VoiceProviderSloReport, type VoiceProviderSloReportOptions } from "./providerSlo";
+import { type VoiceSessionObservabilityEvidenceInput, type VoiceSessionObservabilityReport } from "./sessionObservability";
+import type { VoiceProviderOrchestrationReport } from "./providerOrchestration";
+import type { VoiceCampaignReadinessProofReport } from "./campaign";
+import { type VoiceOpsRecoveryReport } from "./opsRecovery";
+import { type VoiceIncidentRecoveryTrendReport, type VoiceIncidentRecoveryTrendSloOptions, type VoiceIncidentRecoveryOutcomeReadinessOptions, type VoiceIncidentRecoveryOutcomeReport } from "./incidentTimeline";
+import { type VoiceObservabilityExportDeliveryHistory, type VoiceObservabilityExportDeliveryReceiptStore, type VoiceObservabilityExportReplayReport, type VoiceObservabilityExportReplaySource, type VoiceObservabilityExportReport } from "./observabilityExport";
+import type { VoiceMediaPipelineReport } from "./mediaPipelineRoutes";
+import type { VoiceTelephonyMediaReport } from "./telephonyMediaRoutes";
+import type { MediaWebRTCStatsReport } from "@absolutejs/media";
+import { type VoiceProfileSwitchReadinessOptions, type VoiceProfileSwitchReadinessReport } from "./profileSwitchRecommendation";
+export type VoiceProductionReadinessObservabilityExportDeliveryHistoryOptions = {
+    failOnMissing?: boolean;
+    failOnStale?: boolean;
+    history?: VoiceObservabilityExportDeliveryHistory;
+    maxAgeMs?: number;
+    store?: VoiceObservabilityExportDeliveryReceiptStore;
+};
+export type VoiceProductionReadinessStatus = "fail" | "pass" | "warn";
+export type VoiceProductionReconnectEvidence = VoiceReconnectContractReport | VoiceReconnectProofReport;
+export type VoiceProductionReadinessAction = {
+    description?: string;
+    href: string;
+    label: string;
+    method?: "GET" | "POST";
+};
+export type VoiceProductionReadinessGateExplanation = {
+    evidenceHref?: string;
+    observed?: number | string;
+    remediation: string;
+    sourceHref?: string;
+    threshold?: number | string;
+    thresholdLabel?: string;
+    unit?: "count" | "ms" | "rate" | "status";
+};
+export type VoiceProductionReadinessCheck = {
+    actions?: VoiceProductionReadinessAction[];
+    detail?: string;
+    gateExplanation?: VoiceProductionReadinessGateExplanation;
+    href?: string;
+    label: string;
+    proofSource?: VoiceProductionReadinessProofSource;
+    status: VoiceProductionReadinessStatus;
+    value?: number | string;
+};
+export type VoiceReadinessRecoveryAction = VoiceProductionReadinessAction & {
+    key: string;
+    sourceCheckDetail?: string;
+    sourceCheckHref?: string;
+    sourceCheckLabel: string;
+    sourceStatus: Exclude<VoiceProductionReadinessStatus, "pass">;
+};
+export type VoiceReadinessRecoveryActionPlan = {
+    actions: VoiceReadinessRecoveryAction[];
+    generatedAt: string;
+    sourceChecks: number;
+};
+export type VoiceReadinessRecoveryActionOptions = {
+    includeWarnings?: boolean;
+    now?: () => Date;
+};
+export type VoiceProductionReadinessGateIssue = {
+    code: string;
+    detail?: string;
+    href?: string;
+    label: string;
+    status: Exclude<VoiceProductionReadinessStatus, "pass">;
+    value?: number | string;
+};
+export type VoiceProductionReadinessGateOptions = {
+    failOnWarnings?: boolean;
+};
+export declare const buildVoiceReadinessRecoveryActions: (input: VoiceProductionReadinessReport | readonly VoiceProductionReadinessCheck[], options?: VoiceReadinessRecoveryActionOptions) => VoiceReadinessRecoveryActionPlan;
+export type VoiceProductionReadinessGateReport = {
+    checkedAt: number;
+    failures: VoiceProductionReadinessGateIssue[];
+    ok: boolean;
+    profile?: VoiceProductionReadinessGateProfile;
+    status: VoiceProductionReadinessStatus;
+    warnings: VoiceProductionReadinessGateIssue[];
+};
+export type VoiceProductionReadinessAssertionInput = {
+    maxFailures?: number;
+    maxWarnings?: number;
+    requiredChecks?: string[];
+    requireGateOk?: boolean;
+    requireStatus?: VoiceProductionReadinessStatus;
+};
+export type VoiceProductionReadinessAssertionReport = {
+    checks: string[];
+    failures: number;
+    gateOk: boolean;
+    issues: string[];
+    ok: boolean;
+    status: VoiceProductionReadinessStatus;
+    warnings: number;
+};
+export type VoiceProductionReadinessProofSource = {
+    detail?: string;
+    href?: string;
+    label?: string;
+    source: string;
+    sourceLabel: string;
+};
+export type VoiceProductionReadinessProfileSurface = {
+    configured: boolean;
+    href?: string;
+    key: string;
+    label: string;
+};
+export type VoiceProductionReadinessProfileExplanation = {
+    description: string;
+    name: string;
+    purpose: string;
+    surfaces: VoiceProductionReadinessProfileSurface[];
+};
+export type VoiceProductionReadinessProofMetadata = {
+    generatedAt: string;
+    refreshedAt: number;
+    runId: string;
+    source: string;
+};
+export type VoiceProductionReadinessProofRuntimeSeedOptions = {
+    liveLatencyMs?: number;
+    llmElapsedMs?: number;
+    llmProvider?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    sttElapsedMs?: number;
+    sttProvider?: string;
+    ttsElapsedMs?: number;
+    ttsProvider?: string;
+};
+export type VoiceProductionReadinessProofRuntimeOptions = {
+    cacheMs?: number;
+    freshnessHref?: string;
+    freshnessLabel?: string;
+    freshnessMaxAgeMs?: number;
+    proofSource?: string;
+    proofSourceLabel?: string;
+    readinessHref?: string;
+    runId?: () => string;
+    traceMaxAgeMs?: number;
+    trendsHref?: string;
+};
+export type VoiceProductionReadinessProofRuntime = {
+    buildFreshnessCheck: () => Promise<VoiceProductionReadinessCheck>;
+    cache: <TValue>(key: string, loader: () => Promise<TValue> | TValue, cacheMs?: number) => Promise<TValue>;
+    getMetadata: () => VoiceProductionReadinessProofMetadata | undefined;
+    options: Pick<VoiceProductionReadinessRoutesOptions, "cacheMs" | "traceMaxAgeMs">;
+    refresh: (onRefresh?: (metadata: VoiceProductionReadinessProofMetadata) => Promise<void> | void) => Promise<VoiceProductionReadinessProofMetadata>;
+    resetTraceProof: () => Promise<void>;
+    seedTraceProof: (options?: VoiceProductionReadinessProofRuntimeSeedOptions) => Promise<StoredVoiceTraceEvent[]>;
+    store: VoiceTraceEventStore;
+};
+export type VoiceProductionReadinessGateProfileSurface = VoiceProductionReadinessProfileSurface & {
+    issues: VoiceProductionReadinessGateIssue[];
+    status: VoiceProductionReadinessStatus;
+};
+export type VoiceProductionReadinessGateProfile = Omit<VoiceProductionReadinessProfileExplanation, "surfaces"> & {
+    surfaces: VoiceProductionReadinessGateProfileSurface[];
+};
+export type VoiceProductionReadinessReport = {
+    checkedAt: number;
+    checks: VoiceProductionReadinessCheck[];
+    links: {
+        agentSquadContracts?: string;
+        audit?: string;
+        auditDeliveries?: string;
+        bargeIn?: string;
+        campaignReadiness?: string;
+        carriers?: string;
+        deliveryRuntime?: string;
+        handoffs?: string;
+        handoffRetry?: string;
+        liveLatency?: string;
+        operationsRecords?: string;
+        observabilityExport?: string;
+        observabilityExportDeliveries?: string;
+        monitoring?: string;
+        monitoringNotifierDelivery?: string;
+        browserMedia?: string;
+        mediaPipeline?: string;
+        opsActions?: string;
+        opsRecovery?: string;
+        phoneAgentSmoke?: string;
+        profileSwitchLiveDecisions?: string;
+        profileSwitchPolicy?: string;
+        profileSwitchReadiness?: string;
+        telephonyWebhookSecurity?: string;
+        telephonyMedia?: string;
+        providerContracts?: string;
+        providerOrchestration?: string;
+        providerRoutingContracts?: string;
+        providerSlo?: string;
+        incidentRecoveryTrends?: string;
+        quality?: string;
+        reconnectContracts?: string;
+        resilience?: string;
+        sessions?: string;
+        sloReadinessThresholds?: string;
+        sessionObservability?: string;
+        traceDeliveries?: string;
+    };
+    profile?: VoiceProductionReadinessProfileExplanation;
+    proofSources?: Record<string, VoiceProductionReadinessProofSource>;
+    operationsRecords?: VoiceProductionReadinessOperationsRecordLinks;
+    status: VoiceProductionReadinessStatus;
+    summary: {
+        agentSquadContracts?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        audit?: VoiceProductionReadinessAuditSummary;
+        auditDeliveries?: VoiceProductionReadinessAuditDeliverySummary;
+        bargeIn?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            warnings: number;
+        };
+        campaignReadiness?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        carriers?: {
+            failing: number;
+            providers: number;
+            ready: number;
+            status: VoiceProductionReadinessStatus;
+            warnings: number;
+        };
+        deliveryRuntime?: VoiceProductionReadinessDeliveryRuntimeSummary;
+        handoffs: {
+            failed: number;
+            total: number;
+        };
+        liveLatency: {
+            averageLatencyMs?: number;
+            failed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            warnings: number;
+        };
+        monitoring?: {
+            criticalOpen: number;
+            elapsedMs?: number;
+            open: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        monitoringNotifierDelivery?: {
+            elapsedMs?: number;
+            failed: number;
+            notifiers: number;
+            sent: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        mediaPipeline?: {
+            assistantAudioFrames: number;
+            backpressureEvents: number;
+            gapCount: number;
+            inputAudioFrames: number;
+            issues: number;
+            jitterMs?: number;
+            speechRatio: number;
+            status: VoiceProductionReadinessStatus;
+            timestampDriftMs?: number;
+        };
+        browserMedia?: {
+            activeCandidatePairs: number;
+            bytesReceived: number;
+            bytesSent: number;
+            issues: number;
+            jitterMs?: number;
+            liveAudioTracks: number;
+            packetLossRatio: number;
+            roundTripTimeMs?: number;
+            status: VoiceProductionReadinessStatus;
+        };
+        opsActionHistory?: VoiceProductionReadinessOpsActionHistorySummary;
+        opsRecovery?: {
+            issues: number;
+            recoveredFallbacks: number;
+            status: VoiceProductionReadinessStatus;
+            unresolvedProviderFailures: number;
+        };
+        incidentRecoveryOutcomes?: {
+            failed: number;
+            improved: number;
+            regressed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            unchanged: number;
+        };
+        incidentRecoveryTrend?: {
+            cycles: number;
+            failed: number;
+            failureRate: number;
+            improved: number;
+            improvementRate: number;
+            regressed: number;
+            regressionRate: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            unchanged: number;
+            unchangedRate: number;
+        };
+        observabilityExport?: {
+            artifacts: number;
+            auditEvents: number;
+            envelopes: number;
+            issues: number;
+            status: VoiceProductionReadinessStatus;
+            traceEvents: number;
+        };
+        observabilityExportDeliveryHistory?: {
+            delivered: number;
+            failed: number;
+            latestSuccessAgeMs?: number;
+            receipts: number;
+            status: VoiceProductionReadinessStatus;
+            totalDestinations: number;
+        };
+        observabilityExportReplay?: {
+            artifacts: number;
+            deliveryDestinations: number;
+            failedArtifacts: number;
+            failedDeliveryDestinations: number;
+            issues: number;
+            status: VoiceProductionReadinessStatus;
+            validationIssues: number;
+        };
+        providers: {
+            degraded: number;
+            total: number;
+        };
+        providerStack?: VoiceProviderStackCapabilityGapReport;
+        providerContractMatrix?: VoiceProviderContractMatrixReport;
+        providerOrchestration?: {
+            failed: number;
+            issues: number;
+            passed: number;
+            providers: number;
+            status: VoiceProductionReadinessStatus;
+            surfaces: number;
+            warned: number;
+        };
+        providerRecovery: VoiceProviderFallbackRecoverySummary;
+        profileSwitchReadiness?: {
+            auditEvents: number;
+            decisions: number;
+            issues: number;
+            policyCases?: number;
+            sessions: number;
+            status: VoiceProductionReadinessStatus;
+            traceEvents: number;
+        };
+        phoneAgentSmokes?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        telephonyWebhookSecurity?: {
+            enabled: number;
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            warned: number;
+        };
+        telephonyMedia?: {
+            audioBytes: number;
+            carriers: number;
+            failed: number;
+            issues: number;
+            lifecycleFailures: number;
+            mediaEvents: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+        };
+        providerRoutingContracts?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        providerSlo?: {
+            events: number;
+            eventsWithLatency: number;
+            issues: number;
+            status: VoiceProductionReadinessStatus;
+        };
+        reconnectContracts?: {
+            failed: number;
+            passed: number;
+            resumeLatencyP95Ms?: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        sessionObservability?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            warnings: number;
+        };
+        quality: {
+            status: "fail" | "pass";
+        };
+        routing: {
+            events: number;
+            sessions: number;
+        };
+        sessions: {
+            failed: number;
+            total: number;
+        };
+        traceDeliveries?: VoiceProductionReadinessTraceDeliverySummary;
+    };
+};
+export type VoiceProductionReadinessOperationsRecordLink = {
+    detail?: string;
+    href: string;
+    label: string;
+    sessionId: string;
+    status: VoiceProductionReadinessStatus;
+};
+export type VoiceProductionReadinessOperationsRecordLinks = {
+    failedSessions: VoiceProductionReadinessOperationsRecordLink[];
+    failingLatency: VoiceProductionReadinessOperationsRecordLink[];
+    mediaQuality: VoiceProductionReadinessOperationsRecordLink[];
+    providerErrors: VoiceProductionReadinessOperationsRecordLink[];
+    telephonyMedia: VoiceProductionReadinessOperationsRecordLink[];
+};
+export type VoiceProductionReadinessAuditRequirement = {
+    label?: string;
+    maxAgeMs?: number;
+    outcomes?: VoiceAuditOutcome[];
+    status?: VoiceProductionReadinessStatus;
+    type: VoiceAuditEventType;
+};
+export type VoiceProductionReadinessAuditSummary = {
+    events: number;
+    missing: VoiceProductionReadinessAuditRequirement[];
+    present: Record<VoiceAuditEventType, number>;
+    required: VoiceProductionReadinessAuditRequirement[];
+    status: VoiceProductionReadinessStatus;
+};
+export type VoiceProductionReadinessAuditDeliverySummary = {
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    failPendingAfterMs: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    staleFailing: number;
+    staleWarning: number;
+    status: VoiceProductionReadinessStatus;
+    total: number;
+    warnPendingAfterMs: number;
+};
+export type VoiceProductionReadinessTraceDeliverySummary = {
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    failPendingAfterMs: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    staleFailing: number;
+    staleWarning: number;
+    status: VoiceProductionReadinessStatus;
+    total: number;
+    warnPendingAfterMs: number;
+};
+export type VoiceProductionReadinessOpsActionHistorySummary = {
+    failed: number;
+    passed: number;
+    status: VoiceProductionReadinessStatus;
+    total: number;
+    warnWhenEmpty: boolean;
+};
+export type VoiceProductionReadinessDeliveryRuntimeSummary = {
+    audit?: VoiceProductionReadinessDeliveryRuntimeQueueSummary;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    status: VoiceProductionReadinessStatus;
+    total: number;
+    trace?: VoiceProductionReadinessDeliveryRuntimeQueueSummary;
+};
+export type VoiceProductionReadinessDeliveryRuntimeQueueSummary = {
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    total: number;
+};
+export type VoiceProductionReadinessAuditOptions = VoiceAuditEventStore | {
+    require?: readonly (VoiceAuditEventType | VoiceProductionReadinessAuditRequirement)[];
+    store: VoiceAuditEventStore;
+};
+export type VoiceProductionReadinessAuditDeliveryOptions = VoiceAuditSinkDeliveryStore | {
+    deadLetters?: VoiceAuditSinkDeliveryStore;
+    failPendingAfterMs?: number;
+    store: VoiceAuditSinkDeliveryStore;
+    warnPendingAfterMs?: number;
+};
+export type VoiceProductionReadinessTraceDeliveryOptions = VoiceTraceSinkDeliveryStore | {
+    deadLetters?: VoiceTraceSinkDeliveryStore;
+    failPendingAfterMs?: number;
+    store: VoiceTraceSinkDeliveryStore;
+    warnPendingAfterMs?: number;
+};
+export type VoiceProductionReadinessOpsActionHistoryOptions = VoiceAuditEventStore | {
+    failOnFailedActions?: boolean;
+    store: VoiceAuditEventStore;
+    warnWhenEmpty?: boolean;
+};
+export type VoiceProductionReadinessRouteInput = {
+    query: Record<string, unknown>;
+    request: Request;
+};
+export type VoiceProductionReadinessTiming = {
+    durationMs: number;
+    endedAt: number;
+    label: string;
+    startedAt: number;
+};
+export type VoiceProductionReadinessRoutesOptions = {
+    agentSquadContracts?: false | readonly VoiceAgentSquadContractReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceAgentSquadContractReport[]> | readonly VoiceAgentSquadContractReport[]);
+    additionalChecks?: false | readonly VoiceProductionReadinessCheck[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceProductionReadinessCheck[]> | readonly VoiceProductionReadinessCheck[]);
+    audit?: false | VoiceProductionReadinessAuditOptions;
+    auditDeliveries?: false | VoiceProductionReadinessAuditDeliveryOptions;
+    bargeInReports?: false | readonly VoiceBargeInReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceBargeInReport[]> | readonly VoiceBargeInReport[]);
+    carriers?: false | readonly VoiceTelephonyCarrierMatrixInput[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceTelephonyCarrierMatrixInput[]> | readonly VoiceTelephonyCarrierMatrixInput[]);
+    campaignReadiness?: false | VoiceCampaignReadinessProofReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceCampaignReadinessProofReport> | VoiceCampaignReadinessProofReport);
+    cacheMs?: number;
+    deliveryRuntime?: false | VoiceDeliveryRuntime | VoiceDeliveryRuntimeSummary | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceDeliveryRuntime | VoiceDeliveryRuntimeSummary> | VoiceDeliveryRuntime | VoiceDeliveryRuntimeSummary);
+    headers?: HeadersInit;
+    gate?: false | VoiceProductionReadinessGateOptions;
+    gatePath?: false | string;
+    htmlPath?: false | string;
+    links?: VoiceProductionReadinessReport["links"];
+    llmProviders?: readonly string[];
+    name?: string;
+    onTiming?: (timing: VoiceProductionReadinessTiming) => void;
+    monitoring?: false | VoiceMonitorRunReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceMonitorRunReport> | VoiceMonitorRunReport);
+    monitoringNotifierDelivery?: false | VoiceMonitorNotifierDeliveryReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceMonitorNotifierDeliveryReport> | VoiceMonitorNotifierDeliveryReport);
+    mediaPipeline?: false | VoiceMediaPipelineReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceMediaPipelineReport> | VoiceMediaPipelineReport);
+    browserMedia?: false | MediaWebRTCStatsReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<MediaWebRTCStatsReport> | MediaWebRTCStatsReport);
+    telephonyMedia?: false | VoiceTelephonyMediaReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyMediaReport> | VoiceTelephonyMediaReport);
+    opsActionHistory?: false | VoiceProductionReadinessOpsActionHistoryOptions;
+    opsRecovery?: false | VoiceOpsRecoveryReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceOpsRecoveryReport> | VoiceOpsRecoveryReport);
+    incidentRecoveryOutcomes?: false | VoiceIncidentRecoveryOutcomeReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceIncidentRecoveryOutcomeReport> | VoiceIncidentRecoveryOutcomeReport);
+    incidentRecoveryTrend?: false | VoiceIncidentRecoveryTrendReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceIncidentRecoveryTrendReport> | VoiceIncidentRecoveryTrendReport);
+    incidentRecoveryOutcomeReadiness?: false | VoiceIncidentRecoveryOutcomeReadinessOptions;
+    incidentRecoveryTrendSLO?: false | VoiceIncidentRecoveryTrendSloOptions;
+    observabilityExport?: false | VoiceObservabilityExportReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceObservabilityExportReport> | VoiceObservabilityExportReport);
+    observabilityExportDeliveryHistory?: false | VoiceObservabilityExportDeliveryHistory | VoiceObservabilityExportDeliveryReceiptStore | VoiceProductionReadinessObservabilityExportDeliveryHistoryOptions | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceObservabilityExportDeliveryHistory | VoiceObservabilityExportDeliveryReceiptStore | VoiceProductionReadinessObservabilityExportDeliveryHistoryOptions> | VoiceObservabilityExportDeliveryHistory | VoiceObservabilityExportDeliveryReceiptStore | VoiceProductionReadinessObservabilityExportDeliveryHistoryOptions);
+    observabilityExportReplay?: false | VoiceObservabilityExportReplayReport | VoiceObservabilityExportReplaySource | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceObservabilityExportReplayReport | VoiceObservabilityExportReplaySource> | VoiceObservabilityExportReplayReport | VoiceObservabilityExportReplaySource);
+    path?: string;
+    phoneAgentSmokes?: false | readonly VoicePhoneAgentProductionSmokeReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoicePhoneAgentProductionSmokeReport[]> | readonly VoicePhoneAgentProductionSmokeReport[]);
+    telephonyWebhookSecurity?: false | VoiceTelephonyWebhookSecurityReport | VoiceTelephonyWebhookSecurityOptions | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyWebhookSecurityReport | VoiceTelephonyWebhookSecurityOptions> | VoiceTelephonyWebhookSecurityReport | VoiceTelephonyWebhookSecurityOptions);
+    providerRoutingContracts?: false | readonly VoiceProviderRoutingContractReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceProviderRoutingContractReport[]> | readonly VoiceProviderRoutingContractReport[]);
+    providerSlo?: false | VoiceProviderSloReport | VoiceProviderSloReportOptions | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceProviderSloReport | VoiceProviderSloReportOptions> | VoiceProviderSloReport | VoiceProviderSloReportOptions);
+    providerOrchestration?: false | VoiceProviderOrchestrationReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceProviderOrchestrationReport> | VoiceProviderOrchestrationReport);
+    profileSwitchReadiness?: false | VoiceProfileSwitchReadinessReport | VoiceProfileSwitchReadinessOptions | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceProfileSwitchReadinessReport | VoiceProfileSwitchReadinessOptions> | VoiceProfileSwitchReadinessReport | VoiceProfileSwitchReadinessOptions);
+    providerStack?: false | VoiceProviderStackCapabilityGapReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceProviderStackCapabilityGapReport> | VoiceProviderStackCapabilityGapReport);
+    providerContractMatrix?: false | VoiceProviderContractMatrixReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceProviderContractMatrixReport> | VoiceProviderContractMatrixReport);
+    reconnectContracts?: false | readonly VoiceProductionReconnectEvidence[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceProductionReconnectEvidence[]> | readonly VoiceProductionReconnectEvidence[]);
+    proofSources?: false | Record<string, VoiceProductionReadinessProofSource> | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<Record<string, VoiceProductionReadinessProofSource>> | Record<string, VoiceProductionReadinessProofSource>);
+    profile?: false | VoiceProductionReadinessProfileExplanation;
+    render?: (report: VoiceProductionReadinessReport) => string | Promise<string>;
+    resolveOptions?: (input: VoiceProductionReadinessRouteInput) => Promise<Partial<Omit<VoiceProductionReadinessRoutesOptions, "resolveOptions">>> | Partial<Omit<VoiceProductionReadinessRoutesOptions, "resolveOptions">>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    sessionObservability?: false | VoiceSessionObservabilityReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceSessionObservabilityReport> | VoiceSessionObservabilityReport);
+    sessionObservabilityEvidence?: false | VoiceSessionObservabilityEvidenceInput | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceSessionObservabilityEvidenceInput> | VoiceSessionObservabilityEvidenceInput);
+    traceDeliveries?: false | VoiceProductionReadinessTraceDeliveryOptions;
+    ttsProviders?: readonly string[];
+    traceMaxAgeMs?: number;
+    liveLatencyWarnAfterMs?: number;
+    liveLatencyFailAfterMs?: number;
+    liveLatencyMaxAgeMs?: number;
+    monitoringRunFailAfterMs?: number;
+    monitoringNotifierDeliveryFailAfterMs?: number;
+    browserMediaMinActiveCandidatePairs?: number;
+    browserMediaMinLiveAudioTracks?: number;
+    browserMediaMinTotalStats?: number;
+    reconnectContractsMinCount?: number;
+    reconnectContractsMinSnapshotsPerContract?: number;
+    telephonyMediaMinCarriers?: number;
+    telephonyMediaMinMediaEvents?: number;
+    reconnectResumeFailAfterMs?: number;
+};
+export declare const createVoiceProductionReadinessProofRuntime: (options?: VoiceProductionReadinessProofRuntimeOptions) => VoiceProductionReadinessProofRuntime;
+export declare const summarizeVoiceProductionReadinessGate: (report: VoiceProductionReadinessReport, options?: VoiceProductionReadinessGateOptions) => VoiceProductionReadinessGateReport;
+export declare const evaluateVoiceProductionReadinessEvidence: (report: VoiceProductionReadinessReport, input?: VoiceProductionReadinessAssertionInput) => VoiceProductionReadinessAssertionReport;
+export declare const assertVoiceProductionReadinessEvidence: (report: VoiceProductionReadinessReport, input?: VoiceProductionReadinessAssertionInput) => VoiceProductionReadinessAssertionReport;
+export declare const buildVoiceProductionReadinessReport: (options: VoiceProductionReadinessRoutesOptions, input?: {
+    query?: Record<string, unknown>;
+    request?: Request;
+}) => Promise<VoiceProductionReadinessReport>;
+export declare const buildVoiceProductionReadinessGate: (options: VoiceProductionReadinessRoutesOptions, input?: {
+    query?: Record<string, unknown>;
+    request?: Request;
+}) => Promise<VoiceProductionReadinessGateReport>;
+export declare const renderVoiceProductionReadinessHTML: (report: VoiceProductionReadinessReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProductionReadinessRoutes: (options: VoiceProductionReadinessRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;