@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.510

package/dist/client/liveAgentConsole.d.ts

@@ -0,0 +1,28 @@
+import { type CreateLiveCallViewerOptions, type LiveCallTimelineEvent, type LiveCallViewState, type LiveCallViewer } from "./liveCallViewer";
+import type { VoiceCallerMemorySnapshot } from "../callerMemory";
+export type LiveAgentConsoleState = {
+    caller?: VoiceCallerMemorySnapshot;
+    hasTakeover: boolean;
+    recentTimeline: LiveCallTimelineEvent[];
+    takeoverAt?: number;
+    takeoverReason?: string;
+    view: LiveCallViewState;
+};
+export type CreateLiveAgentConsoleOptions = CreateLiveCallViewerOptions & {
+    /** Recent timeline window length. Default 12. */
+    recentLimit?: number;
+    /** Resolves the caller memory snapshot for this session (fetched once on attach). */
+    resolveCaller?: () => Promise<VoiceCallerMemorySnapshot | undefined> | VoiceCallerMemorySnapshot | undefined;
+};
+export type LiveAgentConsole = {
+    getState: () => LiveAgentConsoleState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    releaseTakeover: () => void;
+    setCaller: (caller: VoiceCallerMemorySnapshot | undefined) => void;
+    subscribe: (listener: () => void) => () => void;
+    takeover: (reason?: string) => void;
+    viewer: LiveCallViewer;
+};
+export declare const createLiveAgentConsole: (options: CreateLiveAgentConsoleOptions) => LiveAgentConsole;

package/dist/client/liveCallViewer.d.ts

@@ -0,0 +1,42 @@
+import type { VoiceAgentUIState } from "../agentState";
+export type LiveCallEventKind = "agent_audio" | "agent_text" | "lifecycle" | "transcript" | "tool";
+export type LiveCallTimelineEvent = {
+    at: number;
+    detail?: string;
+    kind: LiveCallEventKind;
+    title: string;
+};
+export type LiveCallViewState = {
+    agentState: VoiceAgentUIState;
+    callDurationMs: number;
+    events: LiveCallTimelineEvent[];
+    isConnected: boolean;
+    isLiveListening: boolean;
+    lastAssistantAt?: number;
+    lastTranscriptAt?: number;
+    partialTranscript: string;
+    sessionId: string;
+};
+export type CreateLiveCallViewerOptions = {
+    bufferLimit?: number;
+    sessionId: string;
+    startedAt?: number;
+};
+export type LiveCallViewer = {
+    applyControl: (control: {
+        reason?: string;
+        type: string;
+    }) => void;
+    applyEvent: (event: 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;
+};
+export declare const createLiveCallViewer: (options: CreateLiveCallViewerOptions) => LiveCallViewer;

package/dist/client/liveOps.d.ts

@@ -0,0 +1,22 @@
+import type { VoiceLiveOpsAction, VoiceLiveOpsActionInput, VoiceLiveOpsActionResult } from "../liveOps";
+export type VoiceLiveOpsClientOptions = {
+    actionPath?: string;
+    fetch?: typeof fetch;
+    onControl?: (result: VoiceLiveOpsActionResult) => Promise<void> | void;
+};
+export type VoiceLiveOpsSnapshot = {
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: VoiceLiveOpsActionResult;
+    runningAction?: VoiceLiveOpsAction;
+    updatedAt?: number;
+};
+export declare const postVoiceLiveOpsAction: (input: VoiceLiveOpsActionInput, options?: VoiceLiveOpsClientOptions) => Promise<VoiceLiveOpsActionResult>;
+export declare const createVoiceLiveOpsStore: (options?: VoiceLiveOpsClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceLiveOpsSnapshot;
+    getSnapshot: () => VoiceLiveOpsSnapshot;
+    run: (input: VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};
+export type { VoiceLiveOpsAction, VoiceLiveOpsActionInput, VoiceLiveOpsActionResult, };

package/dist/client/liveOpsWidget.d.ts

@@ -0,0 +1,23 @@
+import { type VoiceLiveOpsAction, type VoiceLiveOpsActionInput } from "../liveOps";
+import { type VoiceLiveOpsClientOptions, type VoiceLiveOpsSnapshot } from "./liveOps";
+export type VoiceLiveOpsWidgetOptions = VoiceLiveOpsClientOptions & {
+    defaultAssignee?: string;
+    defaultDetail?: string;
+    defaultTag?: string;
+    description?: string;
+    getSessionId?: () => string | null | undefined;
+    title?: string;
+};
+export declare const createVoiceLiveOpsInput: (action: VoiceLiveOpsAction, input: {
+    assignee?: string;
+    detail?: string;
+    sessionId?: string | null;
+    tag?: string;
+}) => VoiceLiveOpsActionInput;
+export declare const renderVoiceLiveOpsHTML: (snapshot: VoiceLiveOpsSnapshot, options?: VoiceLiveOpsWidgetOptions) => string;
+export declare const getVoiceLiveOpsCSS: () => string;
+export declare const mountVoiceLiveOps: (element: Element, options?: VoiceLiveOpsWidgetOptions) => {
+    close: () => void;
+    run: (input: VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+};
+export declare const defineVoiceLiveOpsElement: (tagName?: string, options?: VoiceLiveOpsWidgetOptions) => void;

package/dist/client/liveTurnLatency.d.ts

@@ -0,0 +1,41 @@
+import type { VoiceStreamState } from "../types";
+export type VoiceLiveTurnLatencyStatus = "empty" | "pending" | "pass" | "warn" | "fail";
+export type VoiceLiveTurnLatencyEvent = {
+    assistantAudioAt?: number;
+    assistantTextAt?: number;
+    completedAt?: number;
+    id: string;
+    latencyMs?: number;
+    sessionId?: string | null;
+    startedAt: number;
+    status: Exclude<VoiceLiveTurnLatencyStatus, "empty">;
+    thresholdMs: number;
+};
+export type VoiceLiveTurnLatencySnapshot = {
+    averageLatencyMs?: number;
+    events: VoiceLiveTurnLatencyEvent[];
+    failed: number;
+    lastEvent?: VoiceLiveTurnLatencyEvent;
+    passed: number;
+    pending?: VoiceLiveTurnLatencyEvent;
+    status: VoiceLiveTurnLatencyStatus;
+    thresholdMs: number;
+    total: number;
+    warnings: number;
+};
+export type VoiceLiveTurnLatencyMonitorOptions = {
+    clock?: () => number;
+    failAfterMs?: number;
+    fetch?: typeof fetch;
+    maxEvents?: number;
+    onComplete?: (event: VoiceLiveTurnLatencyEvent) => Promise<void> | void;
+    reportPath?: string;
+    speechThreshold?: number;
+    warnAfterMs?: number;
+};
+export declare const createVoiceLiveTurnLatencyMonitor: (options?: VoiceLiveTurnLatencyMonitorOptions) => {
+    getSnapshot: () => VoiceLiveTurnLatencySnapshot;
+    observe: <TResult = unknown>(state: Pick<VoiceStreamState<TResult>, "assistantAudio" | "assistantTexts" | "sessionId">) => void;
+    recordAudio: (audio: Uint8Array | ArrayBuffer) => VoiceLiveTurnLatencyEvent | undefined;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/microphone.d.ts

@@ -1,9 +1,9 @@
-import type { VoiceCaptureOptions } from '../types';
+import type { VoiceCaptureOptions } from "../types";
 type MicrophoneCaptureOptions = {
-    channelCount?: VoiceCaptureOptions['channelCount'];
-    onLevel?: VoiceCaptureOptions['onLevel'];
+    channelCount?: VoiceCaptureOptions["channelCount"];
+    onLevel?: VoiceCaptureOptions["onLevel"];
     onAudio: (audio: Uint8Array) => void;
-    sampleRateHz?: VoiceCaptureOptions['sampleRateHz'];
+    sampleRateHz?: VoiceCaptureOptions["sampleRateHz"];
 };
 type MicrophoneCapture = {
     start: () => Promise<void>;

package/dist/client/opsActionCenter.d.ts

@@ -0,0 +1,54 @@
+export type VoiceOpsActionMethod = "GET" | "POST";
+export type VoiceOpsActionDescriptor = {
+    description?: string;
+    disabled?: boolean;
+    id: string;
+    label: string;
+    method?: VoiceOpsActionMethod;
+    path: string;
+};
+export type VoiceOpsActionCenterClientOptions = {
+    actions?: VoiceOpsActionDescriptor[];
+    auditPath?: false | string;
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    onActionResult?: (result: VoiceOpsActionRunResult) => Promise<void> | void;
+};
+export type VoiceOpsActionRunResult = {
+    actionId: string;
+    body: unknown;
+    error?: string;
+    ok: boolean;
+    ranAt: number;
+    status: number;
+};
+export declare const recordVoiceOpsActionResult: (result: VoiceOpsActionRunResult, options?: VoiceOpsActionCenterClientOptions) => Promise<void>;
+export type VoiceOpsActionCenterSnapshot = {
+    actions: VoiceOpsActionDescriptor[];
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: VoiceOpsActionRunResult;
+    runningActionId?: string;
+    updatedAt?: number;
+};
+export type VoiceOpsActionCenterPresetOptions = {
+    deliveryRuntimePath?: string;
+    includeDeliveryRuntime?: boolean;
+    includeProductionReadiness?: boolean;
+    includeProviderSimulation?: boolean;
+    includeTurnLatencyProof?: boolean;
+    productionReadinessPath?: string;
+    providerSimulationPathPrefix?: string;
+    providers?: readonly string[];
+    turnLatencyProofPath?: string;
+};
+export declare const createVoiceOpsActionCenterActions: (options?: VoiceOpsActionCenterPresetOptions) => VoiceOpsActionDescriptor[];
+export declare const runVoiceOpsAction: (action: VoiceOpsActionDescriptor, options?: Pick<VoiceOpsActionCenterClientOptions, "fetch">) => Promise<VoiceOpsActionRunResult>;
+export declare const createVoiceOpsActionCenterStore: (options?: VoiceOpsActionCenterClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceOpsActionCenterSnapshot;
+    getSnapshot: () => VoiceOpsActionCenterSnapshot;
+    run: (actionId: string) => Promise<VoiceOpsActionRunResult | undefined>;
+    setActions: (actions: VoiceOpsActionDescriptor[]) => void;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/opsActionCenterWidget.d.ts

@@ -0,0 +1,29 @@
+import { type VoiceOpsActionCenterClientOptions, type VoiceOpsActionCenterSnapshot } from "./opsActionCenter";
+export type VoiceOpsActionCenterViewModel = {
+    actions: Array<{
+        description: string;
+        disabled: boolean;
+        id: string;
+        isRunning: boolean;
+        label: string;
+    }>;
+    description: string;
+    error: string | null;
+    isRunning: boolean;
+    label: string;
+    lastResultLabel: string;
+    status: "ready" | "running" | "error" | "completed";
+    title: string;
+};
+export type VoiceOpsActionCenterWidgetOptions = VoiceOpsActionCenterClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceOpsActionCenterViewModel: (snapshot: VoiceOpsActionCenterSnapshot, options?: VoiceOpsActionCenterWidgetOptions) => VoiceOpsActionCenterViewModel;
+export declare const renderVoiceOpsActionCenterHTML: (snapshot: VoiceOpsActionCenterSnapshot, options?: VoiceOpsActionCenterWidgetOptions) => string;
+export declare const getVoiceOpsActionCenterCSS: () => string;
+export declare const mountVoiceOpsActionCenter: (element: Element, options?: VoiceOpsActionCenterWidgetOptions) => {
+    close: () => void;
+    run: (actionId: string) => Promise<import("./opsActionCenter").VoiceOpsActionRunResult | undefined>;
+};
+export declare const defineVoiceOpsActionCenterElement: (tagName?: string, options?: VoiceOpsActionCenterWidgetOptions) => void;

package/dist/client/opsActionHistory.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceOpsActionHistoryReport } from "../opsActionAuditRoutes";
+export type VoiceOpsActionHistoryClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceOpsActionHistorySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceOpsActionHistoryReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceOpsActionHistory: (path?: string, options?: Pick<VoiceOpsActionHistoryClientOptions, "fetch">) => Promise<VoiceOpsActionHistoryReport>;
+export declare const createVoiceOpsActionHistoryStore: (path?: string, options?: VoiceOpsActionHistoryClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceOpsActionHistorySnapshot;
+    getSnapshot: () => VoiceOpsActionHistorySnapshot;
+    refresh: () => Promise<VoiceOpsActionHistoryReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/opsActionHistoryWidget.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceOpsActionHistoryClientOptions, type VoiceOpsActionHistorySnapshot } from "./opsActionHistory";
+export type VoiceOpsActionHistoryWidgetOptions = VoiceOpsActionHistoryClientOptions & {
+    limit?: number;
+    title?: string;
+};
+export declare const renderVoiceOpsActionHistoryWidgetHTML: (snapshot: VoiceOpsActionHistorySnapshot, options?: VoiceOpsActionHistoryWidgetOptions) => string;
+export declare const getVoiceOpsActionHistoryCSS: () => string;
+export declare const mountVoiceOpsActionHistory: (element: Element, path?: string, options?: VoiceOpsActionHistoryWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceOpsActionHistoryReport | undefined>;
+};

package/dist/client/opsStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceOpsStatusReport } from "../opsStatus";
+export type VoiceOpsStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceOpsStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceOpsStatusReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceOpsStatus: (path?: string, options?: Pick<VoiceOpsStatusClientOptions, "fetch">) => Promise<VoiceOpsStatusReport>;
+export declare const createVoiceOpsStatusStore: (path?: string, options?: VoiceOpsStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceOpsStatusSnapshot;
+    getSnapshot: () => VoiceOpsStatusSnapshot;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/opsStatusWidget.d.ts

@@ -0,0 +1,40 @@
+import type { VoiceOpsStatusReport } from "../opsStatus";
+import { type VoiceOpsStatusClientOptions, type VoiceOpsStatusSnapshot } from "./opsStatus";
+export type VoiceOpsStatusSurfaceView = {
+    detail: string;
+    failed: number;
+    id: string;
+    label: string;
+    status: "pass" | "fail";
+    total: number;
+};
+export type VoiceOpsStatusViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    passed: number;
+    status: "pass" | "fail" | "loading" | "error";
+    surfaces: VoiceOpsStatusSurfaceView[];
+    title: string;
+    total: number;
+    updatedAt?: number;
+};
+export type VoiceOpsStatusWidgetOptions = VoiceOpsStatusClientOptions & {
+    description?: string;
+    includeLinks?: boolean;
+    title?: string;
+};
+export declare const getVoiceOpsStatusLabel: (report?: VoiceOpsStatusReport | null, error?: string | null) => "Needs attention" | "Passing" | "Unavailable" | "Checking";
+export declare const createVoiceOpsStatusViewModel: (snapshot: VoiceOpsStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => VoiceOpsStatusViewModel;
+export declare const renderVoiceOpsStatusHTML: (snapshot: VoiceOpsStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => string;
+export declare const getVoiceOpsStatusCSS: () => string;
+export declare const mountVoiceOpsStatus: (element: Element, path?: string, options?: VoiceOpsStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+};
+export declare const defineVoiceOpsStatusElement: (tagName?: string) => void;

package/dist/client/platformCoverage.d.ts

@@ -0,0 +1,19 @@
+import type { VoicePlatformCoverageSummary } from "../platformCoverage";
+export type VoicePlatformCoverageClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoicePlatformCoverageSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoicePlatformCoverageSummary;
+    updatedAt?: number;
+};
+export declare const fetchVoicePlatformCoverage: (path?: string, options?: Pick<VoicePlatformCoverageClientOptions, "fetch">) => Promise<VoicePlatformCoverageSummary>;
+export declare const createVoicePlatformCoverageStore: (path?: string, options?: VoicePlatformCoverageClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoicePlatformCoverageSnapshot;
+    getSnapshot: () => VoicePlatformCoverageSnapshot;
+    refresh: () => Promise<VoicePlatformCoverageSummary | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/platformCoverageWidget.d.ts

@@ -0,0 +1,37 @@
+import type { VoicePlatformCoverageSurface } from "../platformCoverage";
+import { type VoicePlatformCoverageClientOptions, type VoicePlatformCoverageSnapshot } from "./platformCoverage";
+export type VoicePlatformCoverageSurfaceView = VoicePlatformCoverageSurface & {
+    detail: string;
+    label: string;
+};
+export type VoicePlatformCoverageViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    surfaces: VoicePlatformCoverageSurfaceView[];
+    title: string;
+    updatedAt?: number;
+};
+export type VoicePlatformCoverageWidgetOptions = VoicePlatformCoverageClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    limit?: number;
+    title?: string;
+};
+export declare const createVoicePlatformCoverageViewModel: (snapshot: VoicePlatformCoverageSnapshot, options?: VoicePlatformCoverageWidgetOptions) => VoicePlatformCoverageViewModel;
+export declare const renderVoicePlatformCoverageHTML: (snapshot: VoicePlatformCoverageSnapshot, options?: VoicePlatformCoverageWidgetOptions) => string;
+export declare const getVoicePlatformCoverageCSS: () => string;
+export declare const mountVoicePlatformCoverage: (element: Element, path?: string, options?: VoicePlatformCoverageWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoicePlatformCoverageSummary | undefined>;
+};
+export declare const defineVoicePlatformCoverageElement: (tagName?: string) => void;

package/dist/client/profileComparison.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceRealCallProfileHistoryReport } from "../proofTrends";
+export type VoiceProfileComparisonClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProfileComparisonSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceRealCallProfileHistoryReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProfileComparison: (path?: string, options?: Pick<VoiceProfileComparisonClientOptions, "fetch">) => Promise<VoiceRealCallProfileHistoryReport>;
+export declare const createVoiceProfileComparisonStore: (path?: string, options?: VoiceProfileComparisonClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProfileComparisonSnapshot;
+    getSnapshot: () => VoiceProfileComparisonSnapshot;
+    refresh: () => Promise<VoiceRealCallProfileHistoryReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/profileComparisonWidget.d.ts

@@ -0,0 +1,41 @@
+import { type VoiceProfileComparisonClientOptions, type VoiceProfileComparisonSnapshot } from "./profileComparison";
+export type VoiceProfileComparisonProfileView = {
+    evidence: Array<{
+        label: string;
+        value: string;
+    }>;
+    label: string;
+    nextMove: string;
+    profileId: string;
+    providerRoutes: string;
+    status: string;
+};
+export type VoiceProfileComparisonViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    profiles: VoiceProfileComparisonProfileView[];
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+};
+export type VoiceProfileComparisonWidgetOptions = VoiceProfileComparisonClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    title?: string;
+};
+export declare const createVoiceProfileComparisonViewModel: (snapshot: VoiceProfileComparisonSnapshot, options?: VoiceProfileComparisonWidgetOptions) => VoiceProfileComparisonViewModel;
+export declare const renderVoiceProfileComparisonHTML: (snapshot: VoiceProfileComparisonSnapshot, options?: VoiceProfileComparisonWidgetOptions) => string;
+export declare const getVoiceProfileComparisonCSS: () => string;
+export declare const mountVoiceProfileComparison: (element: Element, path?: string, options?: VoiceProfileComparisonWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceRealCallProfileHistoryReport | undefined>;
+};
+export declare const defineVoiceProfileComparisonElement: (tagName?: string) => void;

package/dist/client/profileSwitchRecommendation.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProfileSwitchRecommendation } from "../profileSwitchRecommendation";
+export type VoiceProfileSwitchRecommendationClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProfileSwitchRecommendationSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    recommendation?: VoiceProfileSwitchRecommendation;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProfileSwitchRecommendation: (path?: string, options?: Pick<VoiceProfileSwitchRecommendationClientOptions, "fetch">) => Promise<VoiceProfileSwitchRecommendation>;
+export declare const createVoiceProfileSwitchRecommendationStore: (path?: string, options?: VoiceProfileSwitchRecommendationClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProfileSwitchRecommendationSnapshot;
+    getSnapshot: () => VoiceProfileSwitchRecommendationSnapshot;
+    refresh: () => Promise<VoiceProfileSwitchRecommendation | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/profileSwitchRecommendationWidget.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProfileSwitchRecommendationClientOptions, type VoiceProfileSwitchRecommendationSnapshot } from "./profileSwitchRecommendation";
+export type VoiceProfileSwitchRecommendationWidgetOptions = VoiceProfileSwitchRecommendationClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const renderVoiceProfileSwitchRecommendationHTML: (snapshot: VoiceProfileSwitchRecommendationSnapshot, options?: VoiceProfileSwitchRecommendationWidgetOptions) => string;
+export declare const getVoiceProfileSwitchRecommendationCSS: () => string;
+export declare const mountVoiceProfileSwitchRecommendation: (element: Element, path?: string, options?: VoiceProfileSwitchRecommendationWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProfileSwitchRecommendation | undefined>;
+};
+export declare const defineVoiceProfileSwitchRecommendationElement: (tagName?: string) => void;

package/dist/client/proofTrends.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProofTrendReport } from "../proofTrends";
+export type VoiceProofTrendsClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProofTrendsSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceProofTrendReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProofTrends: (path?: string, options?: Pick<VoiceProofTrendsClientOptions, "fetch">) => Promise<VoiceProofTrendReport>;
+export declare const createVoiceProofTrendsStore: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProofTrendsSnapshot;
+    getSnapshot: () => VoiceProofTrendsSnapshot;
+    refresh: () => Promise<VoiceProofTrendReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/proofTrendsWidget.d.ts

@@ -0,0 +1,37 @@
+import { type VoiceProofTrendReport } from "../proofTrends";
+import { type VoiceProofTrendsClientOptions, type VoiceProofTrendsSnapshot } from "./proofTrends";
+export type VoiceProofTrendsMetricView = {
+    label: string;
+    value: string;
+};
+export type VoiceProofTrendsViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    metrics: VoiceProofTrendsMetricView[];
+    report?: VoiceProofTrendReport;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProofTrendsWidgetOptions = VoiceProofTrendsClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    title?: string;
+};
+export declare const createVoiceProofTrendsViewModel: (snapshot: VoiceProofTrendsSnapshot, options?: VoiceProofTrendsWidgetOptions) => VoiceProofTrendsViewModel;
+export declare const renderVoiceProofTrendsHTML: (snapshot: VoiceProofTrendsSnapshot, options?: VoiceProofTrendsWidgetOptions) => string;
+export declare const getVoiceProofTrendsCSS: () => string;
+export declare const mountVoiceProofTrends: (element: Element, path?: string, options?: VoiceProofTrendsWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceProofTrendReport | undefined>;
+};
+export declare const defineVoiceProofTrendsElement: (tagName?: string) => void;

package/dist/client/providerCapabilities.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProviderCapabilityReport } from "../providerCapabilities";
+export type VoiceProviderCapabilitiesClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProviderCapabilitiesSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceProviderCapabilityReport<TProvider>;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: Pick<VoiceProviderCapabilitiesClientOptions, "fetch">) => Promise<VoiceProviderCapabilityReport<TProvider>>;
+export declare const createVoiceProviderCapabilitiesStore: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderCapabilitiesSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderCapabilitiesSnapshot<TProvider>;
+    refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/providerCapabilitiesWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceProviderCapabilitySummary } from "../providerCapabilities";
+import { type VoiceProviderCapabilitiesClientOptions, type VoiceProviderCapabilitiesSnapshot } from "./providerCapabilities";
+export type VoiceProviderCapabilityCardView<TProvider extends string = string> = VoiceProviderCapabilitySummary<TProvider> & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceProviderCapabilitiesViewModel<TProvider extends string = string> = {
+    capabilities: VoiceProviderCapabilityCardView<TProvider>[];
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProviderCapabilitiesWidgetOptions = VoiceProviderCapabilitiesClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceProviderCapabilitiesViewModel: <TProvider extends string = string>(snapshot: VoiceProviderCapabilitiesSnapshot<TProvider>, options?: VoiceProviderCapabilitiesWidgetOptions) => VoiceProviderCapabilitiesViewModel<TProvider>;
+export declare const renderVoiceProviderCapabilitiesHTML: <TProvider extends string = string>(snapshot: VoiceProviderCapabilitiesSnapshot<TProvider>, options?: VoiceProviderCapabilitiesWidgetOptions) => string;
+export declare const getVoiceProviderCapabilitiesCSS: () => string;
+export declare const mountVoiceProviderCapabilities: <TProvider extends string = string>(element: Element, path?: string, options?: VoiceProviderCapabilitiesWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+};
+export declare const defineVoiceProviderCapabilitiesElement: (tagName?: string) => void;

package/dist/client/providerContracts.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProviderContractMatrixReport } from "../providerStackRecommendations";
+export type VoiceProviderContractsClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProviderContractsSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceProviderContractMatrixReport<TProvider>;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProviderContracts: <TProvider extends string = string>(path?: string, options?: Pick<VoiceProviderContractsClientOptions, "fetch">) => Promise<VoiceProviderContractMatrixReport<TProvider>>;
+export declare const createVoiceProviderContractsStore: <TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderContractsSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderContractsSnapshot<TProvider>;
+    refresh: () => Promise<VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};