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

package/dist/react/useVoiceAgentSquadStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceAgentSquadStatusClientOptions } from "../client/agentSquadStatus";
+export declare const useVoiceAgentSquadStatus: (path?: string, options?: VoiceAgentSquadStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    error: string | null;
+    isLoading: boolean;
+    report: import("../client").VoiceAgentSquadStatusReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceCallDebugger.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceCallDebuggerClientOptions } from "../client/callDebugger";
+export declare const useVoiceCallDebugger: (path: string, options?: VoiceCallDebuggerClientOptions) => {
+    refresh: () => Promise<import("..").VoiceCallDebuggerReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceCallDebuggerReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceCampaignDialerProofClientOptions } from "../client/campaignDialerProof";
+export declare const useVoiceCampaignDialerProof: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    refresh: () => Promise<import("..").VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<import("..").VoiceCampaignDialerProofReport>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceCampaignDialerProofReport;
+    status?: import("..").VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};

package/dist/react/useVoiceController.d.ts

@@ -1,17 +1,20 @@
-import type { VoiceControllerOptions } from '../types';
+import type { VoiceControllerOptions } from "../types";
 export declare const useVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => {
     bindHTMX: (options: import("..").VoiceHTMXBindingOptions) => () => void;
     callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     startRecording: () => Promise<void>;
     stopRecording: () => void;
     toggleRecording: () => Promise<void>;
     call: import("..").VoiceCallLifecycleState | null;
+    sessionMetadata: Record<string, unknown> | null;
     sessionId: string | null;
     scenarioId: string | null;
     status: import("..").VoiceSessionStatus | "idle";
+    reconnect: import("..").VoiceReconnectClientState;
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];

package/dist/react/useVoiceDeliveryRuntime.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceDeliveryRuntimeClientOptions } from "../client/deliveryRuntime";
+export declare const useVoiceDeliveryRuntime: (path?: string, options?: VoiceDeliveryRuntimeClientOptions) => {
+    requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    refresh: () => Promise<import("..").VoiceDeliveryRuntimeReport | undefined>;
+    tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    actionError: string | null;
+    actionStatus: "idle" | "running" | "completed" | "failed";
+    error: string | null;
+    isLoading: boolean;
+    lastAction?: import("../client").VoiceDeliveryRuntimeActionResult;
+    report?: import("..").VoiceDeliveryRuntimeReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceLiveOps.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceLiveOpsClientOptions } from "../client/liveOps";
+export declare const useVoiceLiveOps: (options?: VoiceLiveOpsClientOptions) => {
+    run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: import("..").VoiceLiveOpsActionResult;
+    runningAction?: import("..").VoiceLiveOpsAction;
+    updatedAt?: number;
+};

package/dist/react/useVoiceOpsActionCenter.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceOpsActionCenterClientOptions } from "../client/opsActionCenter";
+export declare const useVoiceOpsActionCenter: (options?: VoiceOpsActionCenterClientOptions) => {
+    run: (actionId: string) => Promise<import("../client").VoiceOpsActionRunResult | undefined>;
+    setActions: (actions: import("../client").VoiceOpsActionDescriptor[]) => void;
+    actions: import("../client").VoiceOpsActionDescriptor[];
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: import("../client").VoiceOpsActionRunResult;
+    runningActionId?: string;
+    updatedAt?: number;
+};

package/dist/react/useVoiceOpsStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceOpsStatusClientOptions } from "../client/opsStatus";
+export declare const useVoiceOpsStatus: (path?: string, options?: VoiceOpsStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceOpsStatusReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceOpsStatusReport;
+    updatedAt?: number;
+};

package/dist/react/useVoicePlatformCoverage.d.ts

@@ -0,0 +1,8 @@
+import { type VoicePlatformCoverageClientOptions } from "../client/platformCoverage";
+export declare const useVoicePlatformCoverage: (path?: string, options?: VoicePlatformCoverageClientOptions) => {
+    refresh: () => Promise<import("..").VoicePlatformCoverageSummary | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoicePlatformCoverageSummary;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProfileComparison.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProfileComparisonClientOptions } from "../client/profileComparison";
+export declare const useVoiceProfileComparison: (path?: string, options?: VoiceProfileComparisonClientOptions) => {
+    refresh: () => Promise<import("..").VoiceRealCallProfileHistoryReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceRealCallProfileHistoryReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProfileSwitchRecommendation.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProfileSwitchRecommendationClientOptions } from "../client/profileSwitchRecommendation";
+export declare const useVoiceProfileSwitchRecommendation: (path?: string, options?: VoiceProfileSwitchRecommendationClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProfileSwitchRecommendation | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    recommendation?: import("..").VoiceProfileSwitchRecommendation;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProofTrends.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProofTrendsClientOptions } from "../client/proofTrends";
+export declare const useVoiceProofTrends: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProofTrendReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProofTrendReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderCapabilities.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderCapabilitiesClientOptions } from "../client/providerCapabilities";
+export declare const useVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProviderCapabilityReport<TProvider> | undefined;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderContracts.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderContractsClientOptions } from "../client/providerContracts";
+export declare const useVoiceProviderContracts: <TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProviderContractMatrixReport<TProvider> | undefined;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderSimulationControls.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderSimulationControlsOptions } from "../client/providerSimulationControls";
+export declare const useVoiceProviderSimulationControls: <TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    error: string | null;
+    isRunning: boolean;
+    lastResult: import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null;
+    mode: import("../testing").VoiceIOProviderFailureSimulationMode | null;
+    provider: TProvider | null;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderStatus.d.ts

@@ -1,4 +1,4 @@
-import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import { type VoiceProviderStatusClientOptions } from "../client/providerStatus";
 export declare const useVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
     refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
     error: string | null;

package/dist/react/useVoiceReadinessFailures.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceReadinessFailuresClientOptions } from "../client/readinessFailures";
+export declare const useVoiceReadinessFailures: (path?: string, options?: VoiceReadinessFailuresClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProductionReadinessReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProductionReadinessReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceReconnectProfileEvidence.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceReconnectProfileEvidenceClientOptions } from "../client/reconnectProfileEvidence";
+export declare const useVoiceReconnectProfileEvidence: (path?: string, options?: VoiceReconnectProfileEvidenceClientOptions) => {
+    refresh: () => Promise<import("..").VoiceReconnectProfileEvidenceSummary | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceReconnectProfileEvidenceSummary;
+    updatedAt?: number;
+};

package/dist/react/useVoiceRoutingStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceRoutingStatusClientOptions } from "../client/routingStatus";
+export declare const useVoiceRoutingStatus: (path?: string, options?: VoiceRoutingStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    decision: import("..").VoiceRoutingDecisionSummary | null;
+    error: string | null;
+    isLoading: boolean;
+    updatedAt?: number;
+};

package/dist/react/useVoiceSessionObservability.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceSessionObservabilityClientOptions } from "../client/sessionObservability";
+export declare const useVoiceSessionObservability: (path?: string, options?: VoiceSessionObservabilityClientOptions) => {
+    refresh: () => Promise<import("..").VoiceSessionObservabilityReport | null>;
+    error: string | null;
+    isLoading: boolean;
+    report: import("..").VoiceSessionObservabilityReport | null;
+    updatedAt?: number;
+};

package/dist/react/useVoiceSessionSnapshot.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceSessionSnapshotClientOptions } from "../client/sessionSnapshot";
+export declare const useVoiceSessionSnapshot: (path: string, options?: VoiceSessionSnapshotClientOptions) => {
+    download: () => Blob;
+    refresh: () => Promise<import("..").VoiceSessionSnapshot | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    snapshot?: import("..").VoiceSessionSnapshot;
+    updatedAt?: number;
+};

package/dist/react/useVoiceStream.d.ts

@@ -1,13 +1,16 @@
-import type { VoiceConnectionOptions } from '../types';
+import type { VoiceConnectionOptions } from "../types";
 export declare const useVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
     callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     call: import("..").VoiceCallLifecycleState | null;
+    sessionMetadata: Record<string, unknown> | null;
     sessionId: string | null;
     scenarioId: string | null;
     status: import("..").VoiceSessionStatus | "idle";
+    reconnect: import("..").VoiceReconnectClientState;
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];

package/dist/react/useVoiceTraceTimeline.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceTraceTimelineClientOptions } from "../client/traceTimeline";
+export declare const useVoiceTraceTimeline: (path?: string, options?: VoiceTraceTimelineClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    error: string | null;
+    isLoading: boolean;
+    report: import("..").VoiceTraceTimelineReport | null;
+    updatedAt?: number;
+};

package/dist/react/useVoiceTurnLatency.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTurnLatencyClientOptions } from "../client/turnLatency";
+export declare const useVoiceTurnLatency: (path?: string, options?: VoiceTurnLatencyClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceTurnLatencyReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceTurnQuality.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceTurnQualityClientOptions } from "../client/turnQuality";
+export declare const useVoiceTurnQuality: (path?: string, options?: VoiceTurnQualityClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTurnQualityReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceTurnQualityReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceWorkflowStatus.d.ts

@@ -1,4 +1,4 @@
-import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import { type VoiceWorkflowStatusClientOptions } from "../client/workflowStatus";
 export declare const useVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
     refresh: () => Promise<import("..").VoiceScenarioEvalReport | undefined>;
     error: string | null;

package/dist/readinessProfiles.d.ts

@@ -0,0 +1,45 @@
+import type { VoiceProductionReadinessAuditOptions, VoiceProductionReadinessAuditDeliveryOptions, VoiceProductionReadinessOpsActionHistoryOptions, VoiceProductionReadinessRoutesOptions, VoiceProductionReadinessTraceDeliveryOptions } from "./productionReadiness";
+export type VoiceReadinessProfileName = "meeting-recorder" | "ops-heavy" | "phone-agent";
+export type VoiceReadinessProfileOptions = {
+    audit?: VoiceProductionReadinessAuditOptions;
+    auditDeliveries?: VoiceProductionReadinessAuditDeliveryOptions;
+    bargeInReports?: VoiceProductionReadinessRoutesOptions["bargeInReports"];
+    campaignReadiness?: VoiceProductionReadinessRoutesOptions["campaignReadiness"];
+    carriers?: VoiceProductionReadinessRoutesOptions["carriers"];
+    deliveryRuntime?: VoiceProductionReadinessRoutesOptions["deliveryRuntime"];
+    explain?: boolean;
+    gate?: VoiceProductionReadinessRoutesOptions["gate"];
+    links?: VoiceProductionReadinessRoutesOptions["links"];
+    observabilityExportDeliveryHistory?: VoiceProductionReadinessRoutesOptions["observabilityExportDeliveryHistory"];
+    opsActionHistory?: VoiceProductionReadinessOpsActionHistoryOptions;
+    phoneAgentSmokes?: VoiceProductionReadinessRoutesOptions["phoneAgentSmokes"];
+    proofSources?: VoiceProductionReadinessRoutesOptions["proofSources"];
+    providerRoutingContracts?: VoiceProductionReadinessRoutesOptions["providerRoutingContracts"];
+    reconnectContracts?: VoiceProductionReadinessRoutesOptions["reconnectContracts"];
+    reconnectContractsMinCount?: VoiceProductionReadinessRoutesOptions["reconnectContractsMinCount"];
+    reconnectContractsMinSnapshotsPerContract?: VoiceProductionReadinessRoutesOptions["reconnectContractsMinSnapshotsPerContract"];
+    telephonyMediaMinCarriers?: VoiceProductionReadinessRoutesOptions["telephonyMediaMinCarriers"];
+    telephonyMediaMinMediaEvents?: VoiceProductionReadinessRoutesOptions["telephonyMediaMinMediaEvents"];
+    browserMediaMinActiveCandidatePairs?: VoiceProductionReadinessRoutesOptions["browserMediaMinActiveCandidatePairs"];
+    browserMediaMinLiveAudioTracks?: VoiceProductionReadinessRoutesOptions["browserMediaMinLiveAudioTracks"];
+    browserMediaMinTotalStats?: VoiceProductionReadinessRoutesOptions["browserMediaMinTotalStats"];
+    telephonyWebhookSecurity?: VoiceProductionReadinessRoutesOptions["telephonyWebhookSecurity"];
+    traceDeliveries?: VoiceProductionReadinessTraceDeliveryOptions;
+};
+export type VoiceReadinessProfileRoutesOptions = Partial<Omit<VoiceProductionReadinessRoutesOptions, "store">>;
+export type VoiceReadinessProfileRecommendationScore = {
+    configured: string[];
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+};
+export type VoiceReadinessProfileRecommendation = {
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    scores: VoiceReadinessProfileRecommendationScore[];
+};
+export declare const createVoiceReadinessProfile: (profile: VoiceReadinessProfileName, options?: VoiceReadinessProfileOptions) => VoiceReadinessProfileRoutesOptions;
+export declare const recommendVoiceReadinessProfile: (options: VoiceReadinessProfileOptions) => VoiceReadinessProfileRecommendation;

package/dist/realtimeChannel.d.ts

@@ -0,0 +1,136 @@
+import { Elysia } from "elysia";
+import type { AudioFormat } from "./types";
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceRealtimeChannelStatus = "fail" | "pass" | "warn";
+export type VoiceRealtimeChannelRuntimeSample = {
+    format?: AudioFormat;
+    observedAt?: number;
+    kind: "assistant-audio" | "browser-capture" | "input-audio" | "reconnect" | "turn-commit";
+    latencyMs?: number;
+    ok?: boolean;
+    sessionId?: string;
+    source?: string;
+    turnId?: string;
+};
+export type VoiceRealtimeChannelBrowserCapture = {
+    audioContextSampleRateHz?: number;
+    channelCount?: 1 | 2;
+    processorBufferSize?: number;
+    sampleRateHz?: number;
+};
+export type VoiceRealtimeChannelReportOptions = {
+    browserCapture?: VoiceRealtimeChannelBrowserCapture;
+    expectedInputFormat?: AudioFormat;
+    expectedOutputFormat?: AudioFormat;
+    inputFormat?: AudioFormat;
+    maxFirstAudioLatencyMs?: number;
+    minAssistantAudioSamples?: number;
+    minInputAudioSamples?: number;
+    operationsRecordHref?: string;
+    outputFormat?: AudioFormat;
+    provider: string;
+    readinessHref?: string;
+    runtimeSamples?: VoiceRealtimeChannelRuntimeSample[];
+    surface?: string;
+};
+export type VoiceRealtimeChannelIssue = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+};
+export type VoiceRealtimeChannelReport = {
+    browserCapture?: VoiceRealtimeChannelBrowserCapture & {
+        resamplingRequired: boolean;
+        resamplingTargetHz?: number;
+    };
+    checkedAt: number;
+    inputFormat: AudioFormat;
+    issues: VoiceRealtimeChannelIssue[];
+    operationsRecordHref?: string;
+    outputFormat: AudioFormat;
+    provider: string;
+    readinessHref?: string;
+    runtime: {
+        assistantAudioSamples: number;
+        firstAudioLatencyMs?: number;
+        inputAudioSamples: number;
+        samples: VoiceRealtimeChannelRuntimeSample[];
+    };
+    status: VoiceRealtimeChannelStatus;
+    surface: string;
+};
+export type VoiceRealtimeChannelAssertionInput = {
+    maxFirstAudioLatencyMs?: number;
+    minAssistantAudioSamples?: number;
+    minInputAudioSamples?: number;
+    requireBrowserCapture?: boolean;
+    requireOperationsRecordHref?: boolean;
+    requirePass?: boolean;
+    requireReadinessHref?: boolean;
+};
+export type VoiceRealtimeChannelAssertionReport = {
+    issues: string[];
+    ok: boolean;
+    provider: string;
+    status: VoiceRealtimeChannelStatus;
+    surface: string;
+};
+export type VoiceRealtimeChannelRoutesOptions = VoiceRealtimeChannelReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceRealtimeChannelReport) => Promise<string> | string;
+    source?: (() => Promise<VoiceRealtimeChannelReportOptions> | VoiceRealtimeChannelReportOptions) | VoiceRealtimeChannelReportOptions;
+    title?: string;
+};
+export declare const buildVoiceRealtimeChannelRuntimeSamplesFromTrace: (events: readonly StoredVoiceTraceEvent[], options?: {
+    format?: AudioFormat;
+    source?: string;
+}) => VoiceRealtimeChannelRuntimeSample[];
+export declare const buildVoiceRealtimeChannelReport: (options: VoiceRealtimeChannelReportOptions) => VoiceRealtimeChannelReport;
+export declare const evaluateVoiceRealtimeChannelEvidence: (report: VoiceRealtimeChannelReport, input?: VoiceRealtimeChannelAssertionInput) => VoiceRealtimeChannelAssertionReport;
+export declare const assertVoiceRealtimeChannelEvidence: (report: VoiceRealtimeChannelReport, input?: VoiceRealtimeChannelAssertionInput) => VoiceRealtimeChannelAssertionReport;
+export declare const renderVoiceRealtimeChannelMarkdown: (report: VoiceRealtimeChannelReport) => string;
+export declare const renderVoiceRealtimeChannelHTML: (report: VoiceRealtimeChannelReport, title?: string) => string;
+export declare const createVoiceRealtimeChannelRoutes: (options: VoiceRealtimeChannelRoutesOptions) => 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: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/realtimeProviderContracts.d.ts

@@ -0,0 +1,133 @@
+import { Elysia } from "elysia";
+import type { VoiceRealtimeChannelReport } from "./realtimeChannel";
+export type VoiceRealtimeProviderContractStatus = "fail" | "pass" | "warn";
+export type VoiceRealtimeProviderContractCapability = "barge-in" | "browser-format-negotiation" | "duplex-audio" | "first-audio-latency" | "raw-pcm" | "reconnect" | "trace-evidence" | "turn-commit";
+export type VoiceRealtimeProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    implementationStatus?: "available" | "planned";
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    readinessHref?: string;
+    realtimeChannel?: VoiceRealtimeChannelReport;
+    requiredCapabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    requiredEnv?: readonly string[];
+    selected?: boolean;
+    traceHref?: string;
+};
+export type VoiceRealtimeProviderPresetProvider = "gemini-live" | "openai-realtime" | (string & {});
+export type VoiceRealtimeProviderContractMatrixPresetOptions<TProvider extends string = VoiceRealtimeProviderPresetProvider> = {
+    capabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    configured?: Record<string, boolean>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Record<string, readonly TProvider[]>;
+    implementationStatus?: Record<string, "available" | "planned">;
+    latencyBudgets?: Record<string, number>;
+    providers?: readonly TProvider[];
+    readinessHref?: string | Record<string, string | undefined>;
+    realtimeChannels?: Record<string, VoiceRealtimeChannelReport | undefined>;
+    requiredCapabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    requiredEnv?: Record<string, readonly string[]>;
+    selected?: TProvider;
+    traceHref?: string | Record<string, string | undefined>;
+};
+export type VoiceRealtimeProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    status: VoiceRealtimeProviderContractStatus;
+};
+export type VoiceRealtimeProviderContractRow<TProvider extends string = string> = {
+    checks: VoiceRealtimeProviderContractCheck[];
+    configured: boolean;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceRealtimeProviderContractStatus;
+};
+export type VoiceRealtimeProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceRealtimeProviderContractDefinition<TProvider>[];
+};
+export type VoiceRealtimeProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceRealtimeProviderContractRow<TProvider>[];
+    status: VoiceRealtimeProviderContractStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceRealtimeProviderContractAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceRealtimeProviderContractStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireSelected?: boolean;
+    requiredCapabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    requiredCheckKeys?: readonly string[];
+    requiredProviders?: readonly TProvider[];
+};
+export type VoiceRealtimeProviderContractAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedProviders: TProvider[];
+    status: VoiceRealtimeProviderContractStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceRealtimeProviderContractRoutesOptions<TProvider extends string = string> = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    matrix: (() => Promise<VoiceRealtimeProviderContractMatrixInput<TProvider>> | VoiceRealtimeProviderContractMatrixInput<TProvider>) | VoiceRealtimeProviderContractMatrixInput<TProvider>;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceRealtimeProviderContractMatrixReport<TProvider>) => Promise<string> | string;
+    title?: string;
+};
+export declare const createVoiceRealtimeProviderContractMatrixPreset: <TProvider extends string = VoiceRealtimeProviderPresetProvider>(options?: VoiceRealtimeProviderContractMatrixPresetOptions<TProvider>) => VoiceRealtimeProviderContractMatrixInput<TProvider>;
+export declare const buildVoiceRealtimeProviderContractMatrix: <TProvider extends string = string>(input: VoiceRealtimeProviderContractMatrixInput<TProvider>) => VoiceRealtimeProviderContractMatrixReport<TProvider>;
+export declare const evaluateVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;
+export declare const assertVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;
+export declare const renderVoiceRealtimeProviderContractHTML: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, title?: string) => string;
+export declare const createVoiceRealtimeProviderContractRoutes: <TProvider extends string = string>(options: VoiceRealtimeProviderContractRoutesOptions<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: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;