@absolutejs/voice 0.0.22-beta.52 → 0.0.22-beta.520

package/dist/providerStackRecommendations.d.ts

@@ -0,0 +1,187 @@
+import { Elysia } from "elysia";
+import type { VoiceReadinessProfileName } from "./readinessProfiles";
+export type VoiceProviderStackKind = "llm" | "stt" | "tts";
+export type VoiceProviderStackInput<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+};
+export type VoiceProviderStackChoice<TProvider extends string = string> = {
+    alternatives: TProvider[];
+    provider?: TProvider;
+    reasons: string[];
+};
+export type VoiceProviderStackRecommendation<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    recommended: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    stacks: Partial<Record<VoiceProviderStackKind, VoiceProviderStackChoice<TProvider>>>;
+};
+export type VoiceProviderStackCapabilities<TProvider extends string = string> = Partial<Record<VoiceProviderStackKind, Partial<Record<TProvider, readonly string[]>>>>;
+export type VoiceProviderStackCapabilityGap<TProvider extends string = string> = {
+    kind: VoiceProviderStackKind;
+    missing: string[];
+    present: string[];
+    provider?: TProvider;
+    required: string[];
+    status: "fail" | "pass" | "warn";
+};
+export type VoiceProviderStackCapabilityGapReport<TProvider extends string = string> = {
+    gaps: VoiceProviderStackCapabilityGap<TProvider>[];
+    missing: number;
+    profile: VoiceReadinessProfileName;
+    status: "fail" | "pass" | "warn";
+};
+export type VoiceProviderStackAssertionInput<TProvider extends string = string> = {
+    maxMissing?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    requireProviders?: boolean;
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    requiredCapabilities?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderStackAssertionReport<TProvider extends string = string> = {
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    missing: number;
+    ok: boolean;
+    providers: TProvider[];
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderStackCapabilityGapInput<TProvider extends string = string> = VoiceProviderStackInput<TProvider> & {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    recommendation?: VoiceProviderStackRecommendation<TProvider>;
+    required?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderContractCheckStatus = "fail" | "pass" | "warn";
+export type VoiceProviderContractRemediation = {
+    code: string;
+    detail: string;
+    href?: string;
+    label: string;
+};
+export type VoiceProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    remediation?: VoiceProviderContractRemediation;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly string[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    kind: VoiceProviderStackKind;
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    requiredCapabilities?: readonly string[];
+    requiredEnv?: readonly string[];
+    remediationHref?: string;
+    selected?: boolean;
+    streaming?: boolean;
+};
+export type VoiceProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceProviderContractDefinition<TProvider>[];
+};
+export type VoiceProviderContractMatrixPresetOptions<TProvider extends string = string> = {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    configured?: Partial<Record<TProvider, boolean>>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    remediationHref?: string;
+    selected?: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    streaming?: Partial<Record<TProvider, boolean>>;
+};
+export type VoiceProviderContractMatrixHandlerOptions<TProvider extends string = string> = VoiceProviderContractMatrixInput<TProvider> | (() => Promise<VoiceProviderContractMatrixInput<TProvider>> | VoiceProviderContractMatrixInput<TProvider>);
+export type VoiceProviderContractMatrixHTMLHandlerOptions<TProvider extends string = string> = {
+    matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>;
+    render?: (report: VoiceProviderContractMatrixReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderContractMatrixRoutesOptions<TProvider extends string = string> = VoiceProviderContractMatrixHTMLHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceProviderContractMatrixRow<TProvider extends string = string> = {
+    checks: VoiceProviderContractCheck[];
+    configured: boolean;
+    kind: VoiceProviderStackKind;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceProviderContractMatrixRow<TProvider>[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceProviderContractMatrixAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireAllSelected?: boolean;
+    requiredCheckKeys?: string[];
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    selectedKinds?: VoiceProviderStackKind[];
+};
+export type VoiceProviderContractMatrixAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedKinds: VoiceProviderStackKind[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export declare const recommendVoiceProviderStack: <TProvider extends string = string>(input: VoiceProviderStackInput<TProvider>) => VoiceProviderStackRecommendation<TProvider>;
+export declare const buildVoiceProviderContractMatrix: <TProvider extends string = string>(input: VoiceProviderContractMatrixInput<TProvider>) => VoiceProviderContractMatrixReport<TProvider>;
+export declare const evaluateVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const assertVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const createVoiceProviderContractMatrixPreset: <TProvider extends string = string>(profile: VoiceReadinessProfileName, options: VoiceProviderContractMatrixPresetOptions<TProvider>) => VoiceProviderContractMatrixInput<TProvider>;
+export declare const renderVoiceProviderContractMatrixHTML: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderContractMatrixJSONHandler: <TProvider extends string = string>(matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>) => () => Promise<VoiceProviderContractMatrixReport<TProvider>>;
+export declare const createVoiceProviderContractMatrixHTMLHandler: <TProvider extends string = string>(options: VoiceProviderContractMatrixHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderContractMatrixRoutes: <TProvider extends string = string>(options: VoiceProviderContractMatrixRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const evaluateVoiceProviderStackGaps: <TProvider extends string = string>(input: VoiceProviderStackCapabilityGapInput<TProvider>) => VoiceProviderStackCapabilityGapReport<TProvider>;
+export declare const evaluateVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const assertVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;

package/dist/qualityDriftDetector.d.ts

@@ -0,0 +1,44 @@
+import type { VoiceScorecard } from "./callScorecard";
+export type VoiceQualityDriftSeverity = "ok" | "watch" | "regression";
+export type VoiceQualityDriftCriterionAlert = {
+    criterionId: string;
+    baselineAverage: number;
+    currentAverage: number;
+    delta: number;
+    severity: VoiceQualityDriftSeverity;
+};
+export type VoiceQualityDriftReport = {
+    rubricId: string;
+    scope: {
+        from: number;
+        to: number;
+    };
+    baselineWindow: {
+        from: number;
+        to: number;
+        sampleSize: number;
+    };
+    currentWindow: {
+        from: number;
+        to: number;
+        sampleSize: number;
+    };
+    overall: {
+        baselineAverage: number;
+        currentAverage: number;
+        delta: number;
+        severity: VoiceQualityDriftSeverity;
+    };
+    criteria: VoiceQualityDriftCriterionAlert[];
+    alertCount: number;
+};
+export type DetectVoiceQualityDriftInput = {
+    rubricId: string;
+    scorecards: VoiceScorecard[];
+    baselineWindowMs?: number;
+    currentWindowMs?: number;
+    now?: () => number;
+    watchThreshold?: number;
+    regressionThreshold?: number;
+};
+export declare const detectVoiceQualityDrift: (input: DetectVoiceQualityDriftInput) => VoiceQualityDriftReport;

package/dist/qualityRoutes.d.ts

@@ -1,6 +1,6 @@
-import { Elysia } from 'elysia';
-import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from './trace';
-export type VoiceQualityStatus = 'pass' | 'fail';
+import { Elysia } from "elysia";
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from "./trace";
+export type VoiceQualityStatus = "pass" | "fail";
 export type VoiceQualityThresholds = {
     maxDuplicateTurnRate?: number;
     maxEmptyTurnRate?: number;
@@ -16,7 +16,7 @@ export type VoiceQualityMetric = {
     label: string;
     pass: boolean;
     threshold: number;
-    unit: 'count' | 'ms' | 'rate';
+    unit: "count" | "ms" | "rate";
 };
 export type VoiceQualityReport = {
     checkedAt: number;

package/dist/queue.d.ts

@@ -1,14 +1,15 @@
-import type { RedisClient } from 'bun';
-import type { VoiceIntegrationSink } from './opsSinks';
-import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from './trace';
-import type { StoredVoiceHandoffDelivery, VoiceHandoffAdapter, VoiceHandoffDeliveryQueueStatus, VoiceHandoffDeliveryStore, VoiceSessionHandle, VoiceSessionRecord } from './types';
-import type { VoiceOpsTaskPriority, StoredVoiceOpsTask, StoredVoiceIntegrationEvent, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventStore, VoiceIntegrationWebhookConfig, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore } from './ops';
+import type { RedisClient } from "bun";
+import type { VoiceIntegrationSink } from "./opsSinks";
+import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from "./trace";
+import type { VoiceTelephonyWebhookIdempotencyStore } from "./telephonyOutcome";
+import type { StoredVoiceHandoffDelivery, VoiceHandoffAdapter, VoiceHandoffDeliveryQueueStatus, VoiceHandoffDeliveryStore, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+import type { VoiceOpsTaskPriority, StoredVoiceOpsTask, StoredVoiceIntegrationEvent, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventStore, VoiceIntegrationWebhookConfig, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore } from "./ops";
 export type VoiceOpsTaskLease = {
     expiresAt: number;
     taskId: string;
     workerId: string;
 };
-export type VoiceRedisTaskLeaseClient = Pick<RedisClient, 'get' | 'send' | 'set'>;
+export type VoiceRedisTaskLeaseClient = Pick<RedisClient, "get" | "send" | "set">;
 export type VoiceRedisTaskLeaseCoordinatorOptions = {
     client?: VoiceRedisTaskLeaseClient;
     keyPrefix?: string;
@@ -38,13 +39,20 @@ export type VoiceIdempotencyStore = {
         ttlSeconds?: number;
     }) => Promise<void> | void;
 };
-export type VoiceRedisIdempotencyClient = Pick<RedisClient, 'del' | 'exists' | 'set'>;
+export type VoiceRedisIdempotencyClient = Pick<RedisClient, "del" | "exists" | "set">;
 export type VoiceRedisIdempotencyStoreOptions = {
     client?: VoiceRedisIdempotencyClient;
     keyPrefix?: string;
     ttlSeconds?: number;
     url?: string;
 };
+export type VoiceRedisTelephonyWebhookIdempotencyClient = Pick<RedisClient, "get" | "set">;
+export type VoiceRedisTelephonyWebhookIdempotencyStoreOptions = {
+    client?: VoiceRedisTelephonyWebhookIdempotencyClient;
+    keyPrefix?: string;
+    ttlSeconds?: number;
+    url?: string;
+};
 export type VoiceWebhookDeliveryWorkerOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
     deadLetters?: VoiceIntegrationEventStore<TEvent>;
     events: VoiceIntegrationEventStore<TEvent>;
@@ -67,7 +75,7 @@ export type VoiceWebhookDeliveryWorkerResult = {
     skipped: number;
 };
 export type VoiceIntegrationEventQueueSummary = {
-    byType: Array<[StoredVoiceIntegrationEvent['type'], number]>;
+    byType: Array<[StoredVoiceIntegrationEvent["type"], number]>;
     deadLettered: number;
     delivered: number;
     failed: number;
@@ -165,7 +173,7 @@ export type VoiceHandoffDeliveryWorkerOptions<TContext = unknown, TSession exten
     api: VoiceSessionHandle<TContext, TSession, TResult>;
     deadLetters?: VoiceHandoffDeliveryStore<TDelivery>;
     deliveries: VoiceHandoffDeliveryStore<TDelivery>;
-    failMode?: 'record' | 'throw';
+    failMode?: "record" | "throw";
     idempotency?: VoiceIdempotencyStore;
     idempotencyTtlSeconds?: number;
     leaseMs?: number;
@@ -195,7 +203,7 @@ export type VoiceHandoffDeliveryWorkerLoop = {
     tick: () => Promise<VoiceHandoffDeliveryWorkerResult>;
 };
 export type VoiceHandoffDeliveryQueueSummary = {
-    byAction: Array<[StoredVoiceHandoffDelivery['action'], number]>;
+    byAction: Array<[StoredVoiceHandoffDelivery["action"], number]>;
     deadLettered: number;
     delivered: number;
     failed: number;
@@ -262,11 +270,11 @@ export type VoiceOpsTaskProcessorWorkerOptions<TTask extends StoredVoiceOpsTask
     maxFailures?: number;
     onDeadLetter?: (task: TTask) => Promise<void> | void;
     onError?: (error: unknown, task: TTask) => Promise<void> | void;
-    process: (task: TTask) => Promise<void | 'complete' | 'requeue' | {
-        action?: 'complete' | 'requeue';
+    process: (task: TTask) => Promise<void | "complete" | "requeue" | {
+        action?: "complete" | "requeue";
         detail?: string;
-    }> | void | 'complete' | 'requeue' | {
-        action?: 'complete' | 'requeue';
+    }> | void | "complete" | "requeue" | {
+        action?: "complete" | "requeue";
         detail?: string;
     };
     tasks: VoiceOpsTaskStore<TTask>;
@@ -305,6 +313,7 @@ export declare const summarizeVoiceOpsTaskQueue: <TTask extends StoredVoiceOpsTa
 }) => Promise<VoiceOpsTaskQueueSummary> | VoiceOpsTaskQueueSummary;
 export declare const createVoiceRedisTaskLeaseCoordinator: (options?: VoiceRedisTaskLeaseCoordinatorOptions) => VoiceRedisTaskLeaseCoordinator;
 export declare const createVoiceRedisIdempotencyStore: (options?: VoiceRedisIdempotencyStoreOptions) => VoiceIdempotencyStore;
+export declare const createVoiceRedisTelephonyWebhookIdempotencyStore: <TResult = unknown>(options?: VoiceRedisTelephonyWebhookIdempotencyStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
 export declare const createVoiceWebhookDeliveryWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerOptions<TEvent>) => {
     drain: () => Promise<VoiceWebhookDeliveryWorkerResult>;
 };

package/dist/ragTool.d.ts

@@ -0,0 +1,52 @@
+import { type VoiceAgentTool } from "./agent";
+import type { VoiceSessionRecord, VoiceTurnCitation } from "./types";
+export type VoiceRAGQueryResult = {
+    chunkId: string;
+    chunkText: string;
+    score: number;
+    source?: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceRAGSearchInput = {
+    filter?: Record<string, unknown>;
+    query: string;
+    scoreThreshold?: number;
+    signal?: AbortSignal;
+    topK?: number;
+};
+export type VoiceRAGCollectionLike = {
+    search: (input: VoiceRAGSearchInput) => Promise<readonly VoiceRAGQueryResult[]> | readonly VoiceRAGQueryResult[];
+};
+export type VoiceRAGToolArgs = {
+    filter?: Record<string, unknown>;
+    query: string;
+    topK?: number;
+};
+export type VoiceRAGToolResult = {
+    citations: VoiceRAGQueryResult[];
+    message: string;
+    query: string;
+    topK: number;
+};
+export type VoiceRAGCitationSummary = VoiceTurnCitation;
+export declare const extractVoiceRAGCitations: (toolResults: ReadonlyArray<{
+    result?: unknown;
+    toolName: string;
+}>, toolName?: string) => VoiceRAGCitationSummary[];
+export type VoiceRAGToolOptions<TContext = unknown> = {
+    allowedFilterKeys?: readonly string[];
+    description?: string;
+    fixedFilter?: Record<string, unknown> | ((input: {
+        context: TContext;
+    }) => Record<string, unknown> | undefined);
+    formatResult?: (citations: readonly VoiceRAGQueryResult[], args: VoiceRAGToolArgs) => string;
+    maxChunkChars?: number;
+    maxTopK?: number;
+    name?: string;
+    parameters?: Record<string, unknown>;
+    resultToMessage?: (result: VoiceRAGToolResult) => string;
+    scoreThreshold?: number;
+    topK?: number;
+};
+export declare const createVoiceRAGTool: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(collection: VoiceRAGCollectionLike, options?: VoiceRAGToolOptions<TContext>) => VoiceAgentTool<TContext, TSession, VoiceRAGToolArgs, VoiceRAGToolResult>;

package/dist/react/VoiceAgentSquadStatus.d.ts

@@ -0,0 +1,5 @@
+import { type VoiceAgentSquadStatusWidgetOptions } from "../client/agentSquadStatusWidget";
+export type VoiceAgentSquadStatusProps = VoiceAgentSquadStatusWidgetOptions & {
+    path?: string;
+};
+export declare function VoiceAgentSquadStatus({ path, ...options }: VoiceAgentSquadStatusProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceCallDebuggerLaunch.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceCallDebuggerLaunchOptions } from "../client/callDebuggerWidget";
+export type VoiceCallDebuggerLaunchProps = VoiceCallDebuggerLaunchOptions & {
+    className?: string;
+    path: string;
+};
+export declare const VoiceCallDebuggerLaunch: ({ className, path, ...options }: VoiceCallDebuggerLaunchProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceCallPlayer.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceCallPlayer as VoiceCallPlayerHandle, type VoiceCallPlayerOptions } from "../client/callPlayer";
+import type { Transcript } from "../types";
+export type VoiceCallPlayerProps = VoiceCallPlayerOptions & {
+    audioUrl?: string;
+    className?: string;
+    onError?: (error: string) => void;
+    player?: VoiceCallPlayerHandle;
+    title?: string;
+    transcripts?: ReadonlyArray<Transcript>;
+};
+export declare const VoiceCallPlayer: ({ audioUrl, className, onError, player: playerProp, recordingStartedAtEpochMs, title, transcripts, }: VoiceCallPlayerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceCostDashboard.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+import { type VoiceCostDashboardOptions } from "../client/costDashboard";
+export type VoiceCostDashboardProps = Omit<VoiceCostDashboardOptions, "bucketBy"> & {
+    bucketBy?: VoiceCostDashboardOptions["bucketBy"];
+    className?: string;
+    currency?: string;
+    emptyMessage?: ReactNode;
+    title?: string;
+};
+export declare const VoiceCostDashboard: ({ className, currency, emptyMessage, title, ...options }: VoiceCostDashboardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceDeliveryRuntime.d.ts

@@ -0,0 +1,7 @@
+import { type VoiceDeliveryRuntimeWidgetOptions } from "../client/deliveryRuntimeWidget";
+export type VoiceDeliveryRuntimeProps = VoiceDeliveryRuntimeWidgetOptions & {
+    className?: string;
+    includeActions?: boolean;
+    path?: string;
+};
+export declare const VoiceDeliveryRuntime: ({ className, includeActions, path, ...options }: VoiceDeliveryRuntimeProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceLiveAgentConsole.d.ts

@@ -0,0 +1,11 @@
+import { type LiveAgentConsole } from "../client/liveAgentConsole";
+export type VoiceLiveAgentConsoleProps = {
+    className?: string;
+    console?: LiveAgentConsole;
+    onTakeover?: (reason?: string) => void;
+    sessionId?: string;
+    takeoverButtonLabel?: string;
+    takeoverReason?: string;
+    title?: string;
+};
+export declare const VoiceLiveAgentConsole: ({ className, console: consoleProp, onTakeover, sessionId, takeoverButtonLabel, takeoverReason, title, }: VoiceLiveAgentConsoleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceLiveCallViewer.d.ts

@@ -0,0 +1,9 @@
+import { type LiveCallViewer } from "../client/liveCallViewer";
+export type VoiceLiveCallViewerProps = {
+    className?: string;
+    /** Pre-built viewer instance; if omitted, one is created with options.sessionId. */
+    sessionId?: string;
+    title?: string;
+    viewer?: LiveCallViewer;
+};
+export declare const VoiceLiveCallViewer: ({ className, sessionId, title, viewer: viewerProp, }: VoiceLiveCallViewerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceOpsActionCenter.d.ts

@@ -0,0 +1,5 @@
+import { type VoiceOpsActionCenterWidgetOptions } from "../client/opsActionCenterWidget";
+export type VoiceOpsActionCenterProps = VoiceOpsActionCenterWidgetOptions & {
+    className?: string;
+};
+export declare const VoiceOpsActionCenter: ({ className, ...options }: VoiceOpsActionCenterProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceOpsStatus.d.ts

@@ -1,4 +1,4 @@
-import { type VoiceOpsStatusWidgetOptions } from '../client/opsStatusWidget';
+import { type VoiceOpsStatusWidgetOptions } from "../client/opsStatusWidget";
 export type VoiceOpsStatusProps = VoiceOpsStatusWidgetOptions & {
     className?: string;
     path?: string;

package/dist/react/VoicePlatformCoverage.d.ts

@@ -0,0 +1,6 @@
+import { type VoicePlatformCoverageWidgetOptions } from "../client/platformCoverageWidget";
+export type VoicePlatformCoverageProps = VoicePlatformCoverageWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoicePlatformCoverage: ({ className, path, ...options }: VoicePlatformCoverageProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProfileComparison.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProfileComparisonWidgetOptions } from "../client/profileComparisonWidget";
+export type VoiceProfileComparisonProps = VoiceProfileComparisonWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProfileComparison: ({ className, path, ...options }: VoiceProfileComparisonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProfileSwitchRecommendation.d.ts

@@ -0,0 +1,6 @@
+import type { VoiceProfileSwitchRecommendationWidgetOptions } from "../client/profileSwitchRecommendationWidget";
+export type VoiceProfileSwitchRecommendationProps = VoiceProfileSwitchRecommendationWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProfileSwitchRecommendation: ({ className, path, ...options }: VoiceProfileSwitchRecommendationProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProofTrends.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProofTrendsWidgetOptions } from "../client/proofTrendsWidget";
+export type VoiceProofTrendsProps = VoiceProofTrendsWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProofTrends: ({ className, path, ...options }: VoiceProofTrendsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderCapabilities.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProviderCapabilitiesWidgetOptions } from "../client/providerCapabilitiesWidget";
+export type VoiceProviderCapabilitiesProps = VoiceProviderCapabilitiesWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProviderCapabilities: ({ className, path, ...options }: VoiceProviderCapabilitiesProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderContracts.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProviderContractsWidgetOptions } from "../client/providerContractsWidget";
+export type VoiceProviderContractsProps = VoiceProviderContractsWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProviderContracts: ({ className, path, ...options }: VoiceProviderContractsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderSimulationControls.d.ts

@@ -0,0 +1,5 @@
+import type { VoiceProviderSimulationControlsOptions } from "../client/providerSimulationControls";
+export type VoiceProviderSimulationControlsProps<TProvider extends string = string> = VoiceProviderSimulationControlsOptions<TProvider> & {
+    className?: string;
+};
+export declare const VoiceProviderSimulationControls: <TProvider extends string = string>({ className, ...options }: VoiceProviderSimulationControlsProps<TProvider>) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderStatus.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProviderStatusWidgetOptions } from "../client/providerStatusWidget";
+export type VoiceProviderStatusProps = VoiceProviderStatusWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProviderStatus: ({ className, path, ...options }: VoiceProviderStatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceReadinessFailures.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceReadinessFailuresWidgetOptions } from "../client/readinessFailuresWidget";
+export type VoiceReadinessFailuresProps = VoiceReadinessFailuresWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceReadinessFailures: ({ className, path, ...options }: VoiceReadinessFailuresProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceReconnectProfileEvidence.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceReconnectProfileEvidenceWidgetOptions } from "../client/reconnectProfileEvidenceWidget";
+export type VoiceReconnectProfileEvidenceProps = VoiceReconnectProfileEvidenceWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceReconnectProfileEvidence: ({ className, path, ...options }: VoiceReconnectProfileEvidenceProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceReplayTimeline.d.ts

@@ -0,0 +1,6 @@
+import { type ReplayTimelineInput } from "../client/replayTimeline";
+export type VoiceReplayTimelineProps = ReplayTimelineInput & {
+    className?: string;
+    title?: string;
+};
+export declare const VoiceReplayTimeline: ({ artifact, className, title, }: VoiceReplayTimelineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceRoutingStatus.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceRoutingStatusWidgetOptions } from "../client/routingStatusWidget";
+export type VoiceRoutingStatusProps = VoiceRoutingStatusWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceRoutingStatus: ({ className, path, ...options }: VoiceRoutingStatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceSessionObservability.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceSessionObservabilityWidgetOptions } from "../client/sessionObservabilityWidget";
+export type VoiceSessionObservabilityProps = VoiceSessionObservabilityWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceSessionObservability: ({ className, path, ...options }: VoiceSessionObservabilityProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceSessionSnapshot.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceSessionSnapshotWidgetOptions } from "../client/sessionSnapshotWidget";
+export type VoiceSessionSnapshotProps = VoiceSessionSnapshotWidgetOptions & {
+    className?: string;
+    path: string;
+};
+export declare const VoiceSessionSnapshot: ({ className, path, ...options }: VoiceSessionSnapshotProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceTraceTimeline.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceTraceTimelineWidgetOptions } from "../client/traceTimelineWidget";
+export type VoiceTraceTimelineProps = VoiceTraceTimelineWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceTraceTimeline: ({ className, path, ...options }: VoiceTraceTimelineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceTurnLatency.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceTurnLatencyWidgetOptions } from "../client/turnLatencyWidget";
+export type VoiceTurnLatencyProps = VoiceTurnLatencyWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceTurnLatency: ({ className, path, ...options }: VoiceTurnLatencyProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceTurnQuality.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceTurnQualityWidgetOptions } from "../client/turnQualityWidget";
+export type VoiceTurnQualityProps = VoiceTurnQualityWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceTurnQuality: ({ className, path, ...options }: VoiceTurnQualityProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceWidget.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceControllerOptions } from "../types";
+import { type VoiceWidgetLabels, type VoiceWidgetTheme, type VoiceWidgetViewModel } from "../client/voiceWidgetView";
+export type { VoiceWidgetLabels, VoiceWidgetTheme, VoiceWidgetViewModel };
+export type VoiceWidgetProps = {
+    className?: string;
+    controllerOptions?: VoiceControllerOptions;
+    labels?: VoiceWidgetLabels;
+    onError?: (error: string) => void;
+    path?: string;
+    theme?: VoiceWidgetTheme;
+    title?: string;
+};
+export declare const VoiceWidget: ({ className, controllerOptions, labels, onError, path, theme, title, }: VoiceWidgetProps) => import("react/jsx-runtime").JSX.Element;