@absolutejs/voice 0.0.22-beta.16 → 0.0.22-beta.160

package/dist/outcomeContract.d.ts

@@ -0,0 +1,112 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceHandoffDelivery, VoiceCallDisposition, VoiceHandoffAction, VoiceHandoffDeliveryStore, VoiceSessionRecord, VoiceSessionStore } from './types';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventType } from './ops';
+import type { StoredVoiceCallReviewArtifact } from './testing/review';
+export type VoiceOutcomeContractStatus = 'pass' | 'fail';
+export type VoiceOutcomeContractDefinition = {
+    description?: string;
+    expectedDisposition?: VoiceCallDisposition;
+    id: string;
+    label?: string;
+    minSessions?: number;
+    minTasks?: number;
+    requireHandoffActions?: VoiceHandoffAction[];
+    requireIntegrationEvents?: VoiceIntegrationEventType[];
+    requireReview?: boolean;
+    requireTask?: boolean;
+    scenarioId?: string;
+};
+export type VoiceOutcomeContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceOutcomeContractReport = {
+    contractId: string;
+    description?: string;
+    issues: VoiceOutcomeContractIssue[];
+    label?: string;
+    matched: {
+        handoffs: number;
+        integrationEvents: number;
+        reviews: number;
+        sessions: number;
+        tasks: number;
+    };
+    pass: boolean;
+};
+export type VoiceOutcomeContractSuiteReport = {
+    checkedAt: number;
+    contracts: VoiceOutcomeContractReport[];
+    failed: number;
+    passed: number;
+    status: VoiceOutcomeContractStatus;
+    total: number;
+};
+type ListStore<T> = {
+    list: () => Promise<T[]> | T[];
+};
+export type VoiceOutcomeContractOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    contracts: VoiceOutcomeContractDefinition[];
+    events?: StoredVoiceIntegrationEvent[] | ListStore<StoredVoiceIntegrationEvent>;
+    handoffs?: StoredVoiceHandoffDelivery[] | VoiceHandoffDeliveryStore;
+    reviews?: StoredVoiceCallReviewArtifact[] | ListStore<StoredVoiceCallReviewArtifact>;
+    sessions?: TSession[] | VoiceSessionStore<TSession>;
+    tasks?: StoredVoiceOpsTask[] | ListStore<StoredVoiceOpsTask>;
+};
+export type VoiceOutcomeContractHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceOutcomeContractSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOutcomeContractJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => () => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const createVoiceOutcomeContractHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceOutcomeContractRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractRoutesOptions<TSession>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceOutcomeContractSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/phoneAgent.d.ts

@@ -0,0 +1,62 @@
+import { Elysia } from 'elysia';
+import { type PlivoVoiceRoutesOptions } from './telephony/plivo';
+import { type TelnyxVoiceRoutesOptions } from './telephony/telnyx';
+import { type TwilioVoiceRoutesOptions } from './telephony/twilio';
+import { type VoiceTelephonyCarrierMatrix, type VoiceTelephonyCarrierMatrixRoutesOptions } from './telephony/matrix';
+import { type VoicePhoneAgentProductionSmokeRoutesOptions } from './phoneAgentProductionSmoke';
+import type { VoiceSessionRecord } from './types';
+export type VoicePhoneAgentLifecycleStage = 'ringing' | 'answered' | 'media-started' | 'transcript' | 'assistant-response' | 'transfer' | 'voicemail' | 'no-answer' | 'completed' | 'failed';
+type VoicePhoneAgentCarrierBase = {
+    name?: string;
+    smokePath?: false | string;
+    setupPath?: false | string;
+};
+export type VoicePhoneAgentTwilioCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options: TwilioVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: 'twilio';
+};
+export type VoicePhoneAgentTelnyxCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: 'telnyx';
+};
+export type VoicePhoneAgentPlivoCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentCarrierBase & {
+    options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>;
+    provider: 'plivo';
+};
+export type VoicePhoneAgentCarrier<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoicePhoneAgentTwilioCarrier<TContext, TSession, TResult> | VoicePhoneAgentTelnyxCarrier<TContext, TSession, TResult> | VoicePhoneAgentPlivoCarrier<TContext, TSession, TResult>;
+export type VoicePhoneAgentRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    carriers: readonly VoicePhoneAgentCarrier<TContext, TSession, TResult>[];
+    matrix?: false | Omit<VoiceTelephonyCarrierMatrixRoutesOptions, 'load'>;
+    name?: string;
+    productionSmoke?: false | VoicePhoneAgentProductionSmokeRoutesOptions;
+    setup?: false | {
+        path?: string;
+        title?: string;
+    };
+};
+export type VoicePhoneAgentCarrierSummary = {
+    name?: string;
+    provider: 'plivo' | 'telnyx' | 'twilio';
+    setupPath?: false | string;
+    smokePath?: false | string;
+};
+export type VoicePhoneAgentRoutes = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    matrixPath?: string;
+    productionSmokePath?: string;
+    routes: Elysia;
+    setupPath?: string;
+};
+export type VoicePhoneAgentSetupReport = {
+    carriers: VoicePhoneAgentCarrierSummary[];
+    generatedAt: number;
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    matrix?: VoiceTelephonyCarrierMatrix;
+    matrixPath?: string;
+    productionSmokePath?: string;
+    ready: boolean;
+    setupPath?: string;
+    title: string;
+};
+export declare const createVoicePhoneAgent: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoicePhoneAgentRoutesOptions<TContext, TSession, TResult>) => VoicePhoneAgentRoutes;
+export {};

package/dist/phoneAgentProductionSmoke.d.ts

@@ -0,0 +1,115 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceTelephonyContractReport, VoiceTelephonyProvider } from './telephony/contract';
+export type VoicePhoneAgentProductionSmokeRequirement = 'assistant-response' | 'carrier-contract' | 'fresh-trace' | 'lifecycle-outcome' | 'media-started' | 'no-session-error' | 'transcript';
+export type VoicePhoneAgentProductionSmokeIssue = {
+    message: string;
+    requirement: VoicePhoneAgentProductionSmokeRequirement;
+    severity: 'error' | 'warning';
+};
+export type VoicePhoneAgentProductionSmokeReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId: string;
+    generatedAt: number;
+    issues: VoicePhoneAgentProductionSmokeIssue[];
+    maxAgeMs?: number;
+    observed: {
+        assistantResponses: number;
+        carrierContract?: boolean;
+        lifecycleOutcomes: string[];
+        latestEventAt?: number;
+        mediaStarts: number;
+        sessionErrors: number;
+        transcripts: number;
+    };
+    pass: boolean;
+    provider?: TProvider;
+    required: VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    contract?: VoiceTelephonyContractReport<TProvider>;
+    contractId?: string;
+    events?: readonly StoredVoiceTraceEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    provider?: TProvider;
+    required?: readonly VoicePhoneAgentProductionSmokeRequirement[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = Omit<VoicePhoneAgentProductionSmokeOptions<TProvider>, 'events' | 'scenarioId' | 'sessionId' | 'traceId'> & {
+    getContract?: (input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceTelephonyContractReport<TProvider> | undefined> | VoiceTelephonyContractReport<TProvider> | undefined;
+    scenarioId?: string;
+    sessionId?: string;
+    traceId?: string;
+};
+export type VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (report: VoicePhoneAgentProductionSmokeReport<TProvider>) => Promise<string> | string;
+    title?: string;
+};
+export type VoicePhoneAgentProductionSmokeRoutesOptions<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoicePhoneAgentProductionSmokeContract: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeOptions<TProvider>) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const renderVoicePhoneAgentProductionSmokeHTML: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(report: VoicePhoneAgentProductionSmokeReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoicePhoneAgentProductionSmokeJSONHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHandlerOptions<TProvider>) => ({ query, request }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoicePhoneAgentProductionSmokeReport<TProvider>>;
+export declare const createVoicePhoneAgentProductionSmokeHTMLHandler: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeHTMLHandlerOptions<TProvider>) => ({ query, request }: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<Response>;
+export declare const createVoicePhoneAgentProductionSmokeRoutes: <TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider>(options: VoicePhoneAgentProductionSmokeRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoicePhoneAgentProductionSmokeReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/postgresStore.d.ts

@@ -1,6 +1,10 @@
 import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from './audit';
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from './auditSinks';
 import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
 import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { VoiceTelephonyWebhookIdempotencyStore } from './telephonyOutcome';
+import type { VoiceCampaignStore } from './campaign';
 import type { VoiceSessionRecord, VoiceSessionStore } from './types';
 export type VoicePostgresClient = {
     unsafe: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, parameters?: unknown[]) => Promise<TRow[]>;
@@ -12,7 +16,10 @@ export type VoicePostgresStoreOptions = {
     tableName?: string;
     tablePrefix?: string;
 };
-export type VoicePostgresRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+export type VoicePostgresRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
     reviews: VoiceCallReviewStore<TReview>;
@@ -28,4 +35,8 @@ export declare const createVoicePostgresIntegrationEventStore: <TEvent extends S
 export declare const createVoicePostgresExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoicePostgresStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
 export declare const createVoicePostgresTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoicePostgresStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoicePostgresTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoicePostgresRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoicePostgresRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;
+export declare const createVoicePostgresAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoicePostgresStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoicePostgresAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const createVoicePostgresTelephonyWebhookIdempotencyStore: <TResult = unknown>(options: VoicePostgresStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
+export declare const createVoicePostgresCampaignStore: (options: VoicePostgresStoreOptions) => VoiceCampaignStore;
+export declare const createVoicePostgresRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoicePostgresRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery>;

package/dist/productionReadiness.d.ts

@@ -0,0 +1,335 @@
+import { Elysia } from 'elysia';
+import { type VoiceProviderFallbackRecoverySummary } from './sessionReplay';
+import { type VoiceTelephonyCarrierMatrixInput } from './telephony/matrix';
+import 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 } from './reconnectContract';
+import type { VoiceAuditEventStore, VoiceAuditEventType, VoiceAuditOutcome } from './audit';
+import { type VoiceAuditSinkDeliveryStore } from './auditSinks';
+export type VoiceProductionReadinessStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProductionReadinessAction = {
+    description?: string;
+    href: string;
+    label: string;
+    method?: 'GET' | 'POST';
+};
+export type VoiceProductionReadinessCheck = {
+    actions?: VoiceProductionReadinessAction[];
+    detail?: string;
+    href?: string;
+    label: string;
+    proofSource?: VoiceProductionReadinessProofSource;
+    status: VoiceProductionReadinessStatus;
+    value?: number | string;
+};
+export type VoiceProductionReadinessGateIssue = {
+    code: string;
+    detail?: string;
+    href?: string;
+    label: string;
+    status: Exclude<VoiceProductionReadinessStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceProductionReadinessGateOptions = {
+    failOnWarnings?: boolean;
+};
+export type VoiceProductionReadinessGateReport = {
+    checkedAt: number;
+    failures: VoiceProductionReadinessGateIssue[];
+    ok: boolean;
+    status: VoiceProductionReadinessStatus;
+    warnings: VoiceProductionReadinessGateIssue[];
+};
+export type VoiceProductionReadinessProofSource = {
+    detail?: string;
+    href?: string;
+    label?: string;
+    source: string;
+    sourceLabel: string;
+};
+export type VoiceProductionReadinessReport = {
+    checkedAt: number;
+    checks: VoiceProductionReadinessCheck[];
+    links: {
+        agentSquadContracts?: string;
+        audit?: string;
+        auditDeliveries?: string;
+        bargeIn?: string;
+        carriers?: string;
+        deliveryRuntime?: string;
+        handoffs?: string;
+        handoffRetry?: string;
+        liveLatency?: string;
+        opsActions?: string;
+        phoneAgentSmoke?: string;
+        providerRoutingContracts?: string;
+        quality?: string;
+        reconnectContracts?: string;
+        resilience?: string;
+        sessions?: string;
+        traceDeliveries?: string;
+    };
+    proofSources?: Record<string, VoiceProductionReadinessProofSource>;
+    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;
+        };
+        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;
+        };
+        opsActionHistory?: VoiceProductionReadinessOpsActionHistorySummary;
+        providers: {
+            degraded: number;
+            total: number;
+        };
+        providerRecovery: VoiceProviderFallbackRecoverySummary;
+        phoneAgentSmokes?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        providerRoutingContracts?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        reconnectContracts?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+        };
+        quality: {
+            status: 'fail' | 'pass';
+        };
+        routing: {
+            events: number;
+            sessions: number;
+        };
+        sessions: {
+            failed: number;
+            total: number;
+        };
+        traceDeliveries?: VoiceProductionReadinessTraceDeliverySummary;
+    };
+};
+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 VoiceProductionReadinessRoutesOptions = {
+    agentSquadContracts?: false | readonly VoiceAgentSquadContractReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceAgentSquadContractReport[]> | readonly VoiceAgentSquadContractReport[]);
+    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[]);
+    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;
+    opsActionHistory?: false | VoiceProductionReadinessOpsActionHistoryOptions;
+    path?: string;
+    phoneAgentSmokes?: false | readonly VoicePhoneAgentProductionSmokeReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoicePhoneAgentProductionSmokeReport[]> | readonly VoicePhoneAgentProductionSmokeReport[]);
+    providerRoutingContracts?: false | readonly VoiceProviderRoutingContractReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceProviderRoutingContractReport[]> | readonly VoiceProviderRoutingContractReport[]);
+    reconnectContracts?: false | readonly VoiceReconnectContractReport[] | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<readonly VoiceReconnectContractReport[]> | readonly VoiceReconnectContractReport[]);
+    proofSources?: false | Record<string, VoiceProductionReadinessProofSource> | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<Record<string, VoiceProductionReadinessProofSource>> | Record<string, VoiceProductionReadinessProofSource>);
+    render?: (report: VoiceProductionReadinessReport) => string | Promise<string>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    traceDeliveries?: false | VoiceProductionReadinessTraceDeliveryOptions;
+    ttsProviders?: readonly string[];
+    liveLatencyWarnAfterMs?: number;
+    liveLatencyFailAfterMs?: number;
+};
+export declare const summarizeVoiceProductionReadinessGate: (report: VoiceProductionReadinessReport, options?: VoiceProductionReadinessGateOptions) => VoiceProductionReadinessGateReport;
+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: {};
+}>;