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

package/dist/client/providerContractsWidget.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceProviderContractMatrixRow } from "../providerStackRecommendations";
+import { type VoiceProviderContractsClientOptions, type VoiceProviderContractsSnapshot } from "./providerContracts";
+export type VoiceProviderContractRowView<TProvider extends string = string> = VoiceProviderContractMatrixRow<TProvider> & {
+    detail: string;
+    label: string;
+    remediations: Array<{
+        detail: string;
+        href?: string;
+        label: string;
+    }>;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceProviderContractsViewModel<TProvider extends string = string> = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    rows: VoiceProviderContractRowView<TProvider>[];
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProviderContractsWidgetOptions = VoiceProviderContractsClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceProviderContractsViewModel: <TProvider extends string = string>(snapshot: VoiceProviderContractsSnapshot<TProvider>, options?: VoiceProviderContractsWidgetOptions) => VoiceProviderContractsViewModel<TProvider>;
+export declare const renderVoiceProviderContractsHTML: <TProvider extends string = string>(snapshot: VoiceProviderContractsSnapshot<TProvider>, options?: VoiceProviderContractsWidgetOptions) => string;
+export declare const getVoiceProviderContractsCSS: () => string;
+export declare const mountVoiceProviderContracts: <TProvider extends string = string>(element: Element, path?: string, options?: VoiceProviderContractsWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderContractMatrixReport<TProvider> | undefined>;
+};
+export declare const defineVoiceProviderContractsElement: (tagName?: string) => void;

package/dist/client/providerSimulationControls.d.ts

@@ -0,0 +1,33 @@
+import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from "../testing/ioProviderSimulator";
+export type VoiceProviderSimulationProvider<TProvider extends string = string> = {
+    configured?: boolean;
+    provider: TProvider;
+};
+export type VoiceProviderSimulationControlsOptions<TProvider extends string = string> = {
+    fallbackRequiredMessage?: string;
+    fallbackRequiredProvider?: TProvider;
+    failureMessage?: string;
+    failureProviders?: readonly TProvider[];
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    kind?: "stt" | "tts" | string;
+    pathPrefix?: string;
+    providers: readonly VoiceProviderSimulationProvider<TProvider>[];
+    recoveryMessage?: string;
+    title?: string;
+};
+export type VoiceProviderSimulationControlsSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isRunning: boolean;
+    lastResult: VoiceIOProviderFailureSimulationResult<TProvider> | null;
+    mode: VoiceIOProviderFailureSimulationMode | null;
+    provider: TProvider | null;
+    updatedAt?: number;
+};
+export declare const createVoiceProviderSimulationControlsStore: <TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderSimulationControlsSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderSimulationControlsSnapshot<TProvider>;
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/providerSimulationControlsWidget.d.ts

@@ -0,0 +1,20 @@
+import { createVoiceProviderSimulationControlsStore, type VoiceProviderSimulationControlsOptions, type VoiceProviderSimulationControlsSnapshot, type VoiceProviderSimulationProvider } from "./providerSimulationControls";
+export type VoiceProviderSimulationControlsViewModel<TProvider extends string = string> = {
+    canSimulateFailure: boolean;
+    description: string;
+    error: string | null;
+    failureProviders: VoiceProviderSimulationProvider<TProvider>[];
+    isRunning: boolean;
+    label: string;
+    providers: VoiceProviderSimulationProvider<TProvider>[];
+    resultText: string | null;
+    title: string;
+};
+export declare const createVoiceProviderSimulationControlsViewModel: <TProvider extends string = string>(snapshot: VoiceProviderSimulationControlsSnapshot<TProvider>, options: VoiceProviderSimulationControlsOptions<TProvider>) => VoiceProviderSimulationControlsViewModel<TProvider>;
+export declare const renderVoiceProviderSimulationControlsHTML: <TProvider extends string = string>(snapshot: VoiceProviderSimulationControlsSnapshot<TProvider>, options: VoiceProviderSimulationControlsOptions<TProvider>) => string;
+export declare const bindVoiceProviderSimulationControls: <TProvider extends string = string>(element: Element, store: ReturnType<typeof createVoiceProviderSimulationControlsStore<TProvider>>) => () => void;
+export declare const mountVoiceProviderSimulationControls: <TProvider extends string = string>(element: Element, options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    close: () => void;
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+};
+export declare const defineVoiceProviderSimulationControlsElement: (tagName?: string) => void;

package/dist/client/providerStatus.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceProviderHealthSummary } from '../providerHealth';
+import type { VoiceProviderHealthSummary } from "../providerHealth";
 export type VoiceProviderStatusClientOptions = {
     fetch?: typeof fetch;
     intervalMs?: number;

package/dist/client/providerStatusWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceProviderHealthSummary } from "../providerHealth";
+import { type VoiceProviderStatusClientOptions, type VoiceProviderStatusSnapshot } from "./providerStatus";
+export type VoiceProviderStatusCardView<TProvider extends string = string> = VoiceProviderHealthSummary<TProvider> & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceProviderStatusViewModel<TProvider extends string = string> = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    providers: VoiceProviderStatusCardView<TProvider>[];
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProviderStatusWidgetOptions = VoiceProviderStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceProviderStatusViewModel: <TProvider extends string = string>(snapshot: VoiceProviderStatusSnapshot<TProvider>, options?: VoiceProviderStatusWidgetOptions) => VoiceProviderStatusViewModel<TProvider>;
+export declare const renderVoiceProviderStatusHTML: <TProvider extends string = string>(snapshot: VoiceProviderStatusSnapshot<TProvider>, options?: VoiceProviderStatusWidgetOptions) => string;
+export declare const getVoiceProviderStatusCSS: () => string;
+export declare const mountVoiceProviderStatus: <TProvider extends string = string>(element: Element, path?: string, options?: VoiceProviderStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+};
+export declare const defineVoiceProviderStatusElement: (tagName?: string) => void;

package/dist/client/readinessFailures.d.ts

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

package/dist/client/readinessFailuresWidget.d.ts

@@ -0,0 +1,42 @@
+import type { VoiceProductionReadinessCheck } from "../productionReadiness";
+import { type VoiceReadinessFailuresClientOptions, type VoiceReadinessFailuresSnapshot } from "./readinessFailures";
+export type VoiceReadinessFailureView = {
+    evidenceHref?: string;
+    label: string;
+    observed: string;
+    remediation: string;
+    sourceHref?: string;
+    status: VoiceProductionReadinessCheck["status"];
+    threshold: string;
+    thresholdLabel: string;
+};
+export type VoiceReadinessFailuresViewModel = {
+    description: string;
+    error: string | null;
+    failures: VoiceReadinessFailureView[];
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceReadinessFailuresWidgetOptions = VoiceReadinessFailuresClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    title?: string;
+};
+export declare const createVoiceReadinessFailuresViewModel: (snapshot: VoiceReadinessFailuresSnapshot, options?: VoiceReadinessFailuresWidgetOptions) => VoiceReadinessFailuresViewModel;
+export declare const renderVoiceReadinessFailuresHTML: (snapshot: VoiceReadinessFailuresSnapshot, options?: VoiceReadinessFailuresWidgetOptions) => string;
+export declare const getVoiceReadinessFailuresCSS: () => string;
+export declare const mountVoiceReadinessFailures: (element: Element, path?: string, options?: VoiceReadinessFailuresWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProductionReadinessReport | undefined>;
+};
+export declare const defineVoiceReadinessFailuresElement: (tagName?: string) => void;

package/dist/client/reconnectProfileEvidence.d.ts

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

package/dist/client/reconnectProfileEvidenceWidget.d.ts

@@ -0,0 +1,39 @@
+import { type VoiceReconnectProfileEvidenceClientOptions, type VoiceReconnectProfileEvidenceSnapshot } from "./reconnectProfileEvidence";
+export type VoiceReconnectProfileEvidenceMetricView = {
+    label: string;
+    value: string;
+};
+export type VoiceReconnectProfileEvidenceViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    latest?: {
+        profileLabel: string;
+        sessionId: string;
+        surfaces: string;
+    };
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    metrics: VoiceReconnectProfileEvidenceMetricView[];
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+};
+export type VoiceReconnectProfileEvidenceWidgetOptions = VoiceReconnectProfileEvidenceClientOptions & {
+    description?: string;
+    links?: Array<{
+        href: string;
+        label: string;
+    }>;
+    title?: string;
+};
+export declare const createVoiceReconnectProfileEvidenceViewModel: (snapshot: VoiceReconnectProfileEvidenceSnapshot, options?: VoiceReconnectProfileEvidenceWidgetOptions) => VoiceReconnectProfileEvidenceViewModel;
+export declare const renderVoiceReconnectProfileEvidenceHTML: (snapshot: VoiceReconnectProfileEvidenceSnapshot, options?: VoiceReconnectProfileEvidenceWidgetOptions) => string;
+export declare const getVoiceReconnectProfileEvidenceCSS: () => string;
+export declare const mountVoiceReconnectProfileEvidence: (element: Element, path?: string, options?: VoiceReconnectProfileEvidenceWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceReconnectProfileEvidenceSummary | undefined>;
+};
+export declare const defineVoiceReconnectProfileEvidenceElement: (tagName?: string) => void;

package/dist/client/replayTimeline.d.ts

@@ -0,0 +1,26 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+export type ReplayTimelineEvent = {
+    at: number;
+    category: "agent" | "lifecycle" | "tool" | "user";
+    detail?: string;
+    durationMs?: number;
+    label: string;
+};
+export type ReplayTimelineReport = {
+    duration: number;
+    events: ReplayTimelineEvent[];
+    metadata: {
+        artifactId: string;
+        title: string;
+    };
+    startedAt: number;
+    summary: {
+        agentTurns: number;
+        toolCalls: number;
+        userTurns: number;
+    };
+};
+export type ReplayTimelineInput = {
+    artifact: VoiceCallReviewArtifact;
+};
+export declare const buildReplayTimelineReport: (input: ReplayTimelineInput) => ReplayTimelineReport;

package/dist/client/routingStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceRoutingDecisionSummary } from "../resilienceRoutes";
+export type VoiceRoutingStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceRoutingStatusSnapshot = {
+    decision: VoiceRoutingDecisionSummary | null;
+    error: string | null;
+    isLoading: boolean;
+    updatedAt?: number;
+};
+export declare const fetchVoiceRoutingStatus: (path?: string, options?: Pick<VoiceRoutingStatusClientOptions, "fetch">) => Promise<import("..").VoiceRoutingEvent | null>;
+export declare const createVoiceRoutingStatusStore: (path?: string, options?: VoiceRoutingStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceRoutingStatusSnapshot;
+    getSnapshot: () => VoiceRoutingStatusSnapshot;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/routingStatusWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceRoutingDecisionSummary } from "../resilienceRoutes";
+import { type VoiceRoutingStatusClientOptions, type VoiceRoutingStatusSnapshot } from "./routingStatus";
+export type VoiceRoutingStatusViewModel = {
+    activeStack: Array<{
+        label: string;
+        value: string;
+    }>;
+    decision: VoiceRoutingDecisionSummary | null;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    status: "empty" | "error" | "loading" | "ready";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceRoutingStatusWidgetOptions = VoiceRoutingStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceRoutingStatusViewModel: (snapshot: VoiceRoutingStatusSnapshot, options?: VoiceRoutingStatusWidgetOptions) => VoiceRoutingStatusViewModel;
+export declare const renderVoiceRoutingStatusHTML: (snapshot: VoiceRoutingStatusSnapshot, options?: VoiceRoutingStatusWidgetOptions) => string;
+export declare const getVoiceRoutingStatusCSS: () => string;
+export declare const mountVoiceRoutingStatus: (element: Element, path?: string, options?: VoiceRoutingStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+};
+export declare const defineVoiceRoutingStatusElement: (tagName?: string) => void;

package/dist/client/sessionObservability.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceSessionObservabilityReport } from "../sessionObservability";
+export type VoiceSessionObservabilityClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceSessionObservabilitySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceSessionObservabilityReport | null;
+    updatedAt?: number;
+};
+export declare const fetchVoiceSessionObservability: (path: string, options?: Pick<VoiceSessionObservabilityClientOptions, "fetch">) => Promise<VoiceSessionObservabilityReport>;
+export declare const createVoiceSessionObservabilityStore: (path: string, options?: VoiceSessionObservabilityClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceSessionObservabilitySnapshot;
+    getSnapshot: () => VoiceSessionObservabilitySnapshot;
+    refresh: () => Promise<VoiceSessionObservabilityReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/sessionObservabilityWidget.d.ts

@@ -0,0 +1,31 @@
+import type { VoiceSessionObservabilityLink, VoiceSessionObservabilityTurn } from "../sessionObservability";
+import { type VoiceSessionObservabilityClientOptions, type VoiceSessionObservabilitySnapshot } from "./sessionObservability";
+export type VoiceSessionObservabilityTurnView = VoiceSessionObservabilityTurn & {
+    durationLabel: string;
+    label: string;
+};
+export type VoiceSessionObservabilityViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: VoiceSessionObservabilityLink[];
+    sessionId?: string;
+    status: "empty" | "error" | "failed" | "loading" | "ready" | "warning";
+    title: string;
+    turns: VoiceSessionObservabilityTurnView[];
+    updatedAt?: number;
+};
+export type VoiceSessionObservabilityWidgetOptions = VoiceSessionObservabilityClientOptions & {
+    description?: string;
+    maxTurns?: number;
+    title?: string;
+};
+export declare const createVoiceSessionObservabilityViewModel: (snapshot: VoiceSessionObservabilitySnapshot, options?: VoiceSessionObservabilityWidgetOptions) => VoiceSessionObservabilityViewModel;
+export declare const renderVoiceSessionObservabilityHTML: (snapshot: VoiceSessionObservabilitySnapshot, options?: VoiceSessionObservabilityWidgetOptions) => string;
+export declare const getVoiceSessionObservabilityCSS: () => string;
+export declare const mountVoiceSessionObservability: (element: Element, path: string, options?: VoiceSessionObservabilityWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceSessionObservabilityReport | null>;
+};
+export declare const defineVoiceSessionObservabilityElement: (tagName?: string) => void;

package/dist/client/sessionSnapshot.d.ts

@@ -0,0 +1,21 @@
+import type { VoiceSessionSnapshot } from "../sessionSnapshot";
+export type VoiceSessionSnapshotClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    turnId?: string;
+};
+export type VoiceSessionSnapshotClientState = {
+    error: string | null;
+    isLoading: boolean;
+    snapshot?: VoiceSessionSnapshot;
+    updatedAt?: number;
+};
+export declare const fetchVoiceSessionSnapshot: (path: string, options?: Pick<VoiceSessionSnapshotClientOptions, "fetch" | "turnId">) => Promise<VoiceSessionSnapshot>;
+export declare const createVoiceSessionSnapshotStore: (path: string, options?: VoiceSessionSnapshotClientOptions) => {
+    close: () => void;
+    download: () => Blob;
+    getServerSnapshot: () => VoiceSessionSnapshotClientState;
+    getSnapshot: () => VoiceSessionSnapshotClientState;
+    refresh: () => Promise<VoiceSessionSnapshot | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/sessionSnapshotWidget.d.ts

@@ -0,0 +1,33 @@
+import { type VoiceSessionSnapshotClientOptions, type VoiceSessionSnapshotClientState } from "./sessionSnapshot";
+export type VoiceSessionSnapshotViewModel = {
+    artifacts: Array<{
+        href?: string;
+        label: string;
+        status: string;
+    }>;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    showDownload: boolean;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceSessionSnapshotWidgetOptions = VoiceSessionSnapshotClientOptions & {
+    description?: string;
+    downloadLabel?: string;
+    title?: string;
+};
+export declare const createVoiceSessionSnapshotViewModel: (state: VoiceSessionSnapshotClientState, options?: VoiceSessionSnapshotWidgetOptions) => VoiceSessionSnapshotViewModel;
+export declare const renderVoiceSessionSnapshotHTML: (state: VoiceSessionSnapshotClientState, options?: VoiceSessionSnapshotWidgetOptions) => string;
+export declare const mountVoiceSessionSnapshot: (element: Element, path: string, options?: VoiceSessionSnapshotWidgetOptions) => {
+    close: () => void;
+    download: () => Blob;
+    refresh: () => Promise<import("..").VoiceSessionSnapshot | undefined>;
+};
+export declare const defineVoiceSessionSnapshotElement: (tagName?: string) => void;

package/dist/client/store.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceStreamState, VoiceStoreAction } from '../types';
+import type { VoiceStreamState, VoiceStoreAction } from "../types";
 export declare const createVoiceStreamStore: <TResult = unknown>() => {
     dispatch: (action: VoiceStoreAction<TResult>) => void;
     getServerSnapshot: () => VoiceStreamState<TResult>;

package/dist/client/traceTimeline.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceTraceTimelineReport } from "../traceTimeline";
+export type VoiceTraceTimelineClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceTraceTimelineSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceTraceTimelineReport | null;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTraceTimeline: (path?: string, options?: Pick<VoiceTraceTimelineClientOptions, "fetch">) => Promise<VoiceTraceTimelineReport>;
+export declare const createVoiceTraceTimelineStore: (path?: string, options?: VoiceTraceTimelineClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTraceTimelineSnapshot;
+    getSnapshot: () => VoiceTraceTimelineSnapshot;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/traceTimelineWidget.d.ts

@@ -0,0 +1,36 @@
+import type { VoiceTraceTimelineSession } from "../traceTimeline";
+import { type VoiceTraceTimelineClientOptions, type VoiceTraceTimelineSnapshot } from "./traceTimeline";
+export type VoiceTraceTimelineSessionView = VoiceTraceTimelineSession & {
+    detailHref: string;
+    durationLabel: string;
+    incidentBundleHref?: string;
+    label: string;
+    operationsRecordHref?: string;
+    providerLabel: string;
+};
+export type VoiceTraceTimelineViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    sessions: VoiceTraceTimelineSessionView[];
+    status: "empty" | "error" | "failed" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceTraceTimelineWidgetOptions = VoiceTraceTimelineClientOptions & {
+    description?: string;
+    detailBasePath?: string;
+    incidentBundleBasePath?: false | string;
+    limit?: number;
+    operationsRecordBasePath?: false | string;
+    title?: string;
+};
+export declare const createVoiceTraceTimelineViewModel: (snapshot: VoiceTraceTimelineSnapshot, options?: VoiceTraceTimelineWidgetOptions) => VoiceTraceTimelineViewModel;
+export declare const renderVoiceTraceTimelineWidgetHTML: (snapshot: VoiceTraceTimelineSnapshot, options?: VoiceTraceTimelineWidgetOptions) => string;
+export declare const getVoiceTraceTimelineCSS: () => string;
+export declare const mountVoiceTraceTimeline: (element: Element, path?: string, options?: VoiceTraceTimelineWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+};
+export declare const defineVoiceTraceTimelineElement: (tagName?: string) => void;

package/dist/client/turnLatency.d.ts

@@ -0,0 +1,22 @@
+import type { VoiceTurnLatencyReport } from "../turnLatency";
+export type VoiceTurnLatencyClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    proofPath?: string;
+};
+export type VoiceTurnLatencySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceTurnLatencyReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTurnLatency: (path?: string, options?: Pick<VoiceTurnLatencyClientOptions, "fetch">) => Promise<VoiceTurnLatencyReport>;
+export declare const runVoiceTurnLatencyProof: (path: string, options?: Pick<VoiceTurnLatencyClientOptions, "fetch">) => Promise<unknown>;
+export declare const createVoiceTurnLatencyStore: (path?: string, options?: VoiceTurnLatencyClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTurnLatencySnapshot;
+    getSnapshot: () => VoiceTurnLatencySnapshot;
+    refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/turnLatencyWidget.d.ts

@@ -0,0 +1,33 @@
+import type { VoiceTurnLatencyItem } from "../turnLatency";
+import { type VoiceTurnLatencyClientOptions, type VoiceTurnLatencySnapshot } from "./turnLatency";
+export type VoiceTurnLatencyCardView = VoiceTurnLatencyItem & {
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceTurnLatencyViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    proofLabel?: string;
+    showProofAction: boolean;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    turns: VoiceTurnLatencyCardView[];
+    updatedAt?: number;
+};
+export type VoiceTurnLatencyWidgetOptions = VoiceTurnLatencyClientOptions & {
+    description?: string;
+    proofLabel?: string;
+    title?: string;
+};
+export declare const createVoiceTurnLatencyViewModel: (snapshot: VoiceTurnLatencySnapshot, options?: VoiceTurnLatencyWidgetOptions) => VoiceTurnLatencyViewModel;
+export declare const renderVoiceTurnLatencyHTML: (snapshot: VoiceTurnLatencySnapshot, options?: VoiceTurnLatencyWidgetOptions) => string;
+export declare const mountVoiceTurnLatency: (element: Element, path?: string, options?: VoiceTurnLatencyWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+};
+export declare const defineVoiceTurnLatencyElement: (tagName?: string) => void;

package/dist/client/turnQuality.d.ts

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

package/dist/client/turnQualityWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceTurnQualityItem } from "../turnQuality";
+import { type VoiceTurnQualityClientOptions, type VoiceTurnQualitySnapshot } from "./turnQuality";
+export type VoiceTurnQualityCardView = VoiceTurnQualityItem & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceTurnQualityViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    turns: VoiceTurnQualityCardView[];
+    updatedAt?: number;
+};
+export type VoiceTurnQualityWidgetOptions = VoiceTurnQualityClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceTurnQualityViewModel: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => VoiceTurnQualityViewModel;
+export declare const renderVoiceTurnQualityHTML: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => string;
+export declare const getVoiceTurnQualityCSS: () => string;
+export declare const mountVoiceTurnQuality: (element: Element, path?: string, options?: VoiceTurnQualityWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTurnQualityReport | undefined>;
+};
+export declare const defineVoiceTurnQualityElement: (tagName?: string) => void;