@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

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 "../core/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 "../core/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/svelte/createVoiceAgentSquadStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceAgentSquadStatusWidgetOptions } from "../client/agentSquadStatusWidget";
+export declare const createVoiceAgentSquadStatus: (path?: string, options?: VoiceAgentSquadStatusWidgetOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceAgentSquadStatusSnapshot;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceAgentSquadStatusViewModel;
+};

package/dist/svelte/createVoiceCallDebugger.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceCallDebuggerLaunchOptions } from "../client/callDebuggerWidget";
+export declare const createVoiceCallDebugger: (path: string, options?: VoiceCallDebuggerLaunchOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceCallDebuggerLaunchViewModel;
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceCallDebuggerReport | undefined>;
+    getServerSnapshot: () => import("../client").VoiceCallDebuggerClientState;
+    getSnapshot: () => import("../client").VoiceCallDebuggerClientState;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceCallPlayer.d.ts

@@ -0,0 +1,33 @@
+import { type VoiceCallPlayerOptions, type VoiceCallPlayerState } from "../client/callPlayer";
+export type CreateVoiceCallPlayerOptions = VoiceCallPlayerOptions & {
+    title?: string;
+};
+export declare const createVoiceCallPlayer: (options?: CreateVoiceCallPlayerOptions) => {
+    getHTML: () => string;
+    title: string | undefined;
+    getState: () => VoiceCallPlayerState;
+    pause: () => void;
+    play: () => Promise<void>;
+    reset: () => void;
+    seekMs: (positionMs: number) => void;
+    seekToTranscript: (transcriptId: string) => void;
+    setAudioUrl: (url: string | undefined) => void;
+    setBuffered: (seconds: number) => void;
+    setDuration: (durationMs: number) => void;
+    setError: (error: string | undefined) => void;
+    setPlaybackRate: (rate: number) => void;
+    setPlaying: (playing: boolean) => void;
+    setReady: (ready: boolean) => void;
+    setTime: (positionMs: number) => void;
+    setTranscripts: (transcripts: ReadonlyArray<import("..").Transcript>) => void;
+    subscribe: (listener: () => void) => () => void;
+    transcripts: () => ReadonlyArray<import("..").Transcript>;
+};
+export declare const renderVoiceCallPlayerHTML: (state: VoiceCallPlayerState, options?: {
+    title?: string;
+    transcripts?: ReadonlyArray<{
+        id: string;
+        text: string;
+        startedAtMs?: number;
+    }>;
+}) => string;

package/dist/svelte/createVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,9 @@
+import type { VoiceCampaignDialerProofClientOptions } from "../client/campaignDialerProof";
+export declare const createVoiceCampaignDialerProof: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<import("..").VoiceCampaignDialerProofReport>;
+    getServerSnapshot: () => import("../client").VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => import("../client").VoiceCampaignDialerProofSnapshot;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceCostDashboard.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "../client/costDashboard";
+export type CreateVoiceCostDashboardOptions = VoiceCostDashboardOptions & {
+    currency?: string;
+    title?: string;
+};
+export declare const createVoiceCostDashboard: (options: CreateVoiceCostDashboardOptions) => {
+    getReport: () => VoiceCostDashboardReport;
+    getHTML: () => string;
+};
+export declare const renderVoiceCostDashboardHTML: (report: VoiceCostDashboardReport, options?: {
+    currency?: string;
+    title?: string;
+}) => string;

package/dist/svelte/createVoiceDeliveryRuntime.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceDeliveryRuntimeWidgetOptions } from "../client/deliveryRuntimeWidget";
+export declare const createVoiceDeliveryRuntime: (path?: string, options?: VoiceDeliveryRuntimeWidgetOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceDeliveryRuntimeSnapshot;
+    refresh: () => Promise<import("..").VoiceDeliveryRuntimeReport | undefined>;
+    requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    subscribe: (listener: () => void) => () => void;
+    tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceDeliveryRuntimeViewModel;
+};

package/dist/svelte/createVoiceLiveAgentConsole.d.ts

@@ -0,0 +1,23 @@
+import { type CreateLiveAgentConsoleOptions, type LiveAgentConsoleState } from "../client/liveAgentConsole";
+export type CreateVoiceLiveAgentConsoleSvelteOptions = CreateLiveAgentConsoleOptions & {
+    takeoverButtonLabel?: string;
+    title?: string;
+};
+export declare const createVoiceLiveAgentConsole: (options: CreateVoiceLiveAgentConsoleSvelteOptions) => {
+    getHTML: () => string;
+    takeoverButtonLabel: string;
+    title: string;
+    getState: () => LiveAgentConsoleState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    releaseTakeover: () => void;
+    setCaller: (caller: import("..").VoiceCallerMemorySnapshot | undefined) => void;
+    subscribe: (listener: () => void) => () => void;
+    takeover: (reason?: string) => void;
+    viewer: import("..").LiveCallViewer;
+};
+export declare const renderVoiceLiveAgentConsoleHTML: (state: LiveAgentConsoleState, options?: {
+    takeoverButtonLabel?: string;
+    title?: string;
+}) => string;

package/dist/svelte/createVoiceLiveCallViewer.d.ts

@@ -0,0 +1,26 @@
+import { type CreateLiveCallViewerOptions, type LiveCallViewState } from "../client/liveCallViewer";
+export declare const renderVoiceLiveCallViewerHTML: (state: LiveCallViewState, options?: {
+    title?: string;
+}) => string;
+export type CreateVoiceLiveCallViewerSvelteOptions = CreateLiveCallViewerOptions & {
+    title?: string;
+};
+export declare const createVoiceLiveCallViewer: (options: CreateVoiceLiveCallViewerSvelteOptions) => {
+    getHTML: () => string;
+    title: string | undefined;
+    applyControl: (control: {
+        reason?: string;
+        type: string;
+    }) => void;
+    applyEvent: (event: import("..").LiveCallTimelineEvent) => void;
+    applyMonitorEvent: (event: {
+        payload: Record<string, unknown>;
+        type: string;
+    }) => void;
+    getState: () => LiveCallViewState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    reset: (sessionId: string, startedAt?: number) => void;
+    subscribe: (subscriber: () => void) => () => void;
+};

package/dist/svelte/createVoiceLiveOps.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceLiveOpsClientOptions } from "../client/liveOps";
+import { type VoiceLiveOpsWidgetOptions } from "../client/liveOpsWidget";
+export declare const createVoiceLiveOps: (options?: VoiceLiveOpsClientOptions | VoiceLiveOpsWidgetOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceLiveOpsSnapshot;
+    run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+    subscribe: (listener: () => void) => () => void;
+    getHTML: () => string;
+    mount: (element: Element) => {
+        run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+        close: () => void;
+    };
+};

package/dist/svelte/createVoiceOpsActionCenter.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceOpsActionCenterWidgetOptions } from "../client/opsActionCenterWidget";
+export declare const createVoiceOpsActionCenter: (options?: VoiceOpsActionCenterWidgetOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceOpsActionCenterSnapshot;
+    run: (actionId: string) => Promise<import("../client").VoiceOpsActionRunResult | undefined>;
+    setActions: (actions: import("../client").VoiceOpsActionDescriptor[]) => void;
+    subscribe: (listener: () => void) => () => void;
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceOpsActionCenterViewModel;
+};

package/dist/svelte/createVoiceOpsStatus.d.ts

@@ -1,9 +1,9 @@
-import { type VoiceOpsStatusWidgetOptions } from '../client/opsStatusWidget';
+import { type VoiceOpsStatusWidgetOptions } from "../client/opsStatusWidget";
 export declare const createVoiceOpsStatus: (path?: string, options?: VoiceOpsStatusWidgetOptions) => {
     close: () => void;
+    getSnapshot: () => import("../client").VoiceOpsStatusSnapshot;
+    refresh: () => Promise<import("..").VoiceOpsStatusReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
     getHTML: () => string;
-    getSnapshot: () => import("../client").VoiceAppKitStatusSnapshot;
     getViewModel: () => import("../client").VoiceOpsStatusViewModel;
-    refresh: () => Promise<import("..").VoiceAppKitStatusReport | undefined>;
-    subscribe: (listener: () => void) => () => void;
 };

package/dist/svelte/createVoicePlatformCoverage.d.ts

@@ -0,0 +1,7 @@
+import type { VoicePlatformCoverageClientOptions } from "../client/platformCoverage";
+export declare const createVoicePlatformCoverage: (path?: string, options?: VoicePlatformCoverageClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client/platformCoverage").VoicePlatformCoverageSnapshot;
+    refresh: () => Promise<import("..").VoicePlatformCoverageSummary | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProfileComparison.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceProfileComparisonClientOptions } from "../client/profileComparison";
+export declare const createVoiceProfileComparison: (path?: string, options?: VoiceProfileComparisonClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceProfileComparisonSnapshot;
+    refresh: () => Promise<import("..").VoiceRealCallProfileHistoryReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProofTrends.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceProofTrendsClientOptions } from "../client/proofTrends";
+export declare const createVoiceProofTrends: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client/proofTrends").VoiceProofTrendsSnapshot;
+    refresh: () => Promise<import("..").VoiceProofTrendReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderCapabilities.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderCapabilitiesWidgetOptions } from "../client/providerCapabilitiesWidget";
+export declare const createVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderCapabilitiesViewModel<TProvider>;
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+    getServerSnapshot: () => import("../client").VoiceProviderCapabilitiesSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderCapabilitiesSnapshot<TProvider>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderContracts.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderContractsWidgetOptions } from "../client/providerContractsWidget";
+export declare const createVoiceProviderContracts: <TProvider extends string = string>(path?: string, options?: VoiceProviderContractsWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderContractsViewModel<TProvider>;
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    getServerSnapshot: () => import("../client").VoiceProviderContractsSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderContractsSnapshot<TProvider>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderSimulationControls.d.ts

@@ -0,0 +1,11 @@
+import type { VoiceProviderSimulationControlsOptions } from "../client/providerSimulationControls";
+export declare const createVoiceProviderSimulationControls: <TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    bind: (element: Element) => () => void;
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderSimulationControlsViewModel<TProvider>;
+    close: () => void;
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    getServerSnapshot: () => import("../client").VoiceProviderSimulationControlsSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderSimulationControlsSnapshot<TProvider>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceProviderStatus.d.ts

@@ -1,8 +1,10 @@
-import type { VoiceProviderStatusClientOptions } from '../client/providerStatus';
-export declare const createVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+import { type VoiceProviderStatusWidgetOptions } from "../client/providerStatusWidget";
+export declare const createVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceProviderStatusViewModel<TProvider>;
     close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
     getServerSnapshot: () => import("../client").VoiceProviderStatusSnapshot<TProvider>;
     getSnapshot: () => import("../client").VoiceProviderStatusSnapshot<TProvider>;
-    refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
     subscribe: (listener: () => void) => () => void;
 };

package/dist/svelte/createVoiceReadinessFailures.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceReadinessFailuresClientOptions } from "../client/readinessFailures";
+export declare const createVoiceReadinessFailures: (path?: string, options?: VoiceReadinessFailuresClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceReadinessFailuresSnapshot;
+    refresh: () => Promise<import("..").VoiceProductionReadinessReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceReconnectProfileEvidence.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceReconnectProfileEvidenceClientOptions } from "../client/reconnectProfileEvidence";
+export declare const createVoiceReconnectProfileEvidence: (path?: string, options?: VoiceReconnectProfileEvidenceClientOptions) => {
+    close: () => void;
+    getSnapshot: () => import("../client").VoiceReconnectProfileEvidenceSnapshot;
+    refresh: () => Promise<import("..").VoiceReconnectProfileEvidenceSummary | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceReplayTimeline.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type ReplayTimelineReport } from "../client/replayTimeline";
+export declare const renderVoiceReplayTimelineHTML: (report: ReplayTimelineReport, options?: {
+    title?: string;
+}) => string;
+export type CreateVoiceReplayTimelineOptions = {
+    artifact: VoiceCallReviewArtifact;
+    title?: string;
+};
+export declare const createVoiceReplayTimeline: (options: CreateVoiceReplayTimelineOptions) => {
+    getReport: () => ReplayTimelineReport;
+    getHTML: () => string;
+};

package/dist/svelte/createVoiceRoutingStatus.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceRoutingStatusWidgetOptions } from "../client/routingStatusWidget";
+export declare const createVoiceRoutingStatus: (path?: string, options?: VoiceRoutingStatusWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceRoutingStatusViewModel;
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    getServerSnapshot: () => import("../client").VoiceRoutingStatusSnapshot;
+    getSnapshot: () => import("../client").VoiceRoutingStatusSnapshot;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/createVoiceSessionObservability.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceSessionObservabilityWidgetOptions } from "../client/sessionObservabilityWidget";
+export declare const createVoiceSessionObservability: (path?: string, options?: VoiceSessionObservabilityWidgetOptions) => {
+    getHTML: () => string;
+    getViewModel: () => import("../client").VoiceSessionObservabilityViewModel;
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceSessionObservabilityReport | null>;
+    getServerSnapshot: () => import("../client").VoiceSessionObservabilitySnapshot;
+    getSnapshot: () => import("../client").VoiceSessionObservabilitySnapshot;
+    subscribe: (listener: () => void) => () => void;
+};