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

package/dist/campaignControls.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceCampaign, VoiceCampaignAttemptStatus, VoiceCampaignRecipient, VoiceCampaignRecord, VoiceCampaignTimeWindow } from "./campaign";
+export type VoiceCampaignDisposition = "answered" | "busy" | "failed" | "no-answer" | "voicemail";
+export type VoiceCampaignDispositionRetryRule = {
+    backoffMs?: number;
+    maxAttempts?: number;
+    retry?: boolean;
+};
+export type VoiceCampaignDispositionRetryPolicy = Partial<Record<VoiceCampaignDisposition, VoiceCampaignDispositionRetryRule>>;
+export type VoiceDNCList = {
+    contains: (phone: string) => boolean | Promise<boolean>;
+};
+export declare const normalizePhoneNumber: (phone: string) => string;
+export declare const createInMemoryDNCList: (phones: ReadonlyArray<string>) => VoiceDNCList;
+export declare const isPhoneOnDNC: (phone: string, list: VoiceDNCList) => Promise<boolean>;
+export type VoiceCampaignWindowCheckInput = {
+    now?: Date;
+    window: VoiceCampaignTimeWindow;
+};
+export declare const isWithinCampaignWindow: (input: VoiceCampaignWindowCheckInput) => boolean;
+export declare const shouldRetryCampaignAttempt: (input: {
+    attempts: number;
+    campaign: Pick<VoiceCampaign, "maxAttempts">;
+    disposition?: VoiceCampaignDisposition;
+    policy?: VoiceCampaignDispositionRetryPolicy;
+}) => {
+    backoffMs?: number;
+    retry: boolean;
+};
+export type VoiceCampaignDispositionSummary = {
+    attempts: number;
+    byDisposition: Partial<Record<VoiceCampaignDisposition, number>>;
+    byStatus: Record<VoiceCampaignAttemptStatus, number>;
+    campaignId: string;
+    recipientsByStatus: Record<VoiceCampaignRecipient["status"], number>;
+    totalRecipients: number;
+};
+export declare const summarizeVoiceCampaignDispositions: (record: VoiceCampaignRecord) => VoiceCampaignDispositionSummary;

package/dist/campaignDialers.d.ts

@@ -0,0 +1,111 @@
+import { applyVoiceCampaignTelephonyOutcome, VoiceCampaignDialer, VoiceCampaignDialerInput, type VoiceCampaignRecord, type VoiceCampaignStore, type VoiceCampaignTickResult } from "./campaign";
+type VoiceCampaignDialerFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type VoiceCampaignDialerMetadataInput = VoiceCampaignDialerInput & {
+    provider: "plivo" | "telnyx" | "twilio";
+};
+type VoiceCampaignDialerMetadata = Record<string, string | number | boolean | undefined> | ((input: VoiceCampaignDialerMetadataInput) => Record<string, string | number | boolean | undefined> | Promise<Record<string, string | number | boolean | undefined>>);
+type VoiceCampaignURLInput = {
+    attempt: VoiceCampaignDialerInput["attempt"];
+    campaign: VoiceCampaignDialerInput["campaign"];
+    recipient: VoiceCampaignDialerInput["recipient"];
+};
+type VoiceCampaignURLResolver = string | ((input: VoiceCampaignURLInput) => string | Promise<string>);
+export type VoiceTwilioCampaignDialerOptions = {
+    accountSid: string;
+    answerMethod?: "GET" | "POST";
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authToken: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    machineDetection?: string;
+    metadata?: VoiceCampaignDialerMetadata;
+    statusCallbackEvents?: string[];
+    statusCallbackMethod?: "GET" | "POST";
+    statusCallbackUrl?: VoiceCampaignURLResolver;
+};
+export type VoiceTelnyxCampaignDialerOptions = {
+    apiBaseUrl?: string;
+    apiKey: string;
+    clientState?: VoiceCampaignDialerMetadata;
+    connectionId: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    webhookUrl?: VoiceCampaignURLResolver;
+    webhookUrlMethod?: "GET" | "POST";
+};
+export type VoicePlivoCampaignDialerOptions = {
+    answerMethod?: "GET" | "POST";
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authId: string;
+    authToken: string;
+    callbackMethod?: "GET" | "POST";
+    callbackUrl?: VoiceCampaignURLResolver;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    metadata?: VoiceCampaignDialerMetadata;
+};
+export type VoiceCampaignDialerProofProvider = "plivo" | "telnyx" | "twilio";
+export type VoiceCampaignDialerProofCarrierRequest = {
+    body: unknown;
+    method: string;
+    provider: VoiceCampaignDialerProofProvider;
+    url: string;
+};
+export type VoiceCampaignDialerProofProviderResult = {
+    campaignId: string;
+    carrierRequests: VoiceCampaignDialerProofCarrierRequest[];
+    final?: VoiceCampaignRecord;
+    outcomes: Awaited<ReturnType<typeof applyVoiceCampaignTelephonyOutcome>>[];
+    provider: VoiceCampaignDialerProofProvider;
+    tick: VoiceCampaignTickResult;
+};
+export type VoiceCampaignDialerProofReport = {
+    generatedAt: number;
+    mode: "dry-run";
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProviderResult[];
+};
+export type VoiceCampaignDialerProofStatus = {
+    generatedAt: number;
+    mode: "dry-run";
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    safe: true;
+};
+export type VoiceCampaignDialerProofOptions = {
+    baseUrl?: string;
+    from?: string;
+    providers?: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    store?: VoiceCampaignStore;
+};
+export type VoiceCampaignDialerProofAssertionInput = {
+    maxFailedProviders?: number;
+    minCarrierRequests?: number;
+    minProviders?: number;
+    minSuccessfulOutcomes?: number;
+    requiredProviders?: VoiceCampaignDialerProofProvider[];
+    requireDryRun?: boolean;
+    requireOk?: boolean;
+};
+export type VoiceCampaignDialerProofAssertionReport = {
+    carrierRequests: number;
+    failedProviders: number;
+    issues: string[];
+    mode: VoiceCampaignDialerProofReport["mode"];
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    successfulOutcomes: number;
+    totalProviders: number;
+};
+export declare const createVoiceTwilioCampaignDialer: (options: VoiceTwilioCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoiceTelnyxCampaignDialer: (options: VoiceTelnyxCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoicePlivoCampaignDialer: (options: VoicePlivoCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const getVoiceCampaignDialerProofStatus: (options?: Pick<VoiceCampaignDialerProofOptions, "providers" | "runPath">) => VoiceCampaignDialerProofStatus;
+export declare const runVoiceCampaignDialerProof: (options?: VoiceCampaignDialerProofOptions) => Promise<VoiceCampaignDialerProofReport>;
+export declare const evaluateVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export declare const assertVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export {};

package/dist/campaignTemplate.d.ts

@@ -0,0 +1,16 @@
+export type VoiceCampaignTemplateValue = string | number | boolean | null | undefined;
+export type VoiceCampaignTemplateScope = Record<string, VoiceCampaignTemplateValue | Record<string, VoiceCampaignTemplateValue>>;
+export type VoiceCampaignTemplateFilter = (value: VoiceCampaignTemplateValue, ...args: string[]) => VoiceCampaignTemplateValue;
+export type VoiceCampaignTemplateResolveResult = {
+    output: string;
+    missingVariables: string[];
+};
+export type ResolveVoiceCampaignTemplateOptions = {
+    scope: VoiceCampaignTemplateScope;
+    filters?: Record<string, VoiceCampaignTemplateFilter>;
+    fallback?: string;
+    strict?: boolean;
+};
+export declare const DEFAULT_VOICE_CAMPAIGN_TEMPLATE_FILTERS: Record<string, VoiceCampaignTemplateFilter>;
+export declare const resolveVoiceCampaignTemplate: (template: string, options: ResolveVoiceCampaignTemplateOptions) => VoiceCampaignTemplateResolveResult;
+export declare const collectVoiceCampaignTemplateVariables: (template: string) => string[];

package/dist/client/actions.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceServerMessage } from '../types';
+import type { VoiceServerMessage } from "../types";
 export declare const serverMessageToAction: <TResult = unknown>(message: VoiceServerMessage<TResult>) => {
     chunk: Uint8Array<ArrayBuffer>;
     format: import("..").AudioFormat;
@@ -7,11 +7,17 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     type: "audio";
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     text: string;
@@ -21,11 +27,17 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
@@ -35,11 +47,37 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    reconnect: import("..").VoiceReconnectClientState;
+    type: "connection";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    sessionId?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    scenarioId?: undefined;
+    sessionMetadata?: undefined;
+    status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     event: import("..").VoiceCallLifecycleEvent;
@@ -50,10 +88,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    reconnect?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     message: string;
@@ -64,10 +108,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -78,10 +128,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -92,13 +148,40 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    assistantTexts: string[];
+    call: import("..").VoiceCallLifecycleState | undefined;
+    partial: string;
+    scenarioId: string | undefined;
+    sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
+    status: import("..").VoiceSessionStatus;
+    turns: import("..").VoiceTurnRecord<TResult>[];
+    type: "replay";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
     scenarioId: string | undefined;
     status: import("..").VoiceSessionStatus;
     type: "session";
@@ -107,9 +190,14 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     turn: import("..").VoiceTurnRecord<TResult>;
@@ -120,9 +208,15 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
     event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
 } | null;

package/dist/client/agentSquadStatus.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceTraceTimelineReport } from "../traceTimeline";
+import { type VoiceTraceTimelineClientOptions } from "./traceTimeline";
+export type VoiceAgentSquadSpecialistStatus = "active" | "blocked" | "handoff" | "idle" | "unknown-target";
+export type VoiceAgentSquadSpecialist = {
+    fromAgentId?: string;
+    lastEventAt?: number;
+    reason?: string;
+    sessionId: string;
+    status: VoiceAgentSquadSpecialistStatus;
+    summary?: string;
+    targetAgentId?: string;
+    turnId?: string;
+};
+export type VoiceAgentSquadStatusReport = {
+    active: VoiceAgentSquadSpecialist[];
+    checkedAt?: number;
+    current?: VoiceAgentSquadSpecialist;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+};
+export type VoiceAgentSquadStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceAgentSquadStatusReport;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusClientOptions = VoiceTraceTimelineClientOptions & {
+    sessionId?: string;
+};
+export declare const buildVoiceAgentSquadStatusReport: (timeline: VoiceTraceTimelineReport | null | undefined, options?: Pick<VoiceAgentSquadStatusClientOptions, "sessionId">) => VoiceAgentSquadStatusReport;
+export declare const createVoiceAgentSquadStatusStore: (path?: string, options?: VoiceAgentSquadStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    getSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/agentSquadStatusWidget.d.ts

@@ -0,0 +1,24 @@
+import { type VoiceAgentSquadSpecialist, type VoiceAgentSquadStatusClientOptions, type VoiceAgentSquadStatusSnapshot } from "./agentSquadStatus";
+export type VoiceAgentSquadStatusViewModel = {
+    current?: VoiceAgentSquadSpecialist;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusWidgetOptions = VoiceAgentSquadStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceAgentSquadStatusViewModel: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => VoiceAgentSquadStatusViewModel;
+export declare const renderVoiceAgentSquadStatusHTML: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => string;
+export declare const getVoiceAgentSquadStatusCSS: () => string;
+export declare const mountVoiceAgentSquadStatus: (element: Element | null, path?: string, options?: VoiceAgentSquadStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+};
+export declare const defineVoiceAgentSquadStatusElement: (tagName?: string, options?: VoiceAgentSquadStatusWidgetOptions) => void;

package/dist/client/audioPlayer.d.ts

@@ -1,4 +1,4 @@
-import type { AudioFormat, VoiceAudioPlayer, VoiceAudioPlayerOptions, VoiceAudioPlayerSource } from '../types';
+import type { AudioFormat, VoiceAudioPlayer, VoiceAudioPlayerOptions, VoiceAudioPlayerSource } from "../types";
 type MinimalAudioBuffer = {
     duration: number;
     getChannelData: (channel: number) => Float32Array;
@@ -29,7 +29,7 @@ type MinimalAudioContext = {
     destination: unknown;
     outputLatency?: number;
     resume: () => Promise<void>;
-    state: 'closed' | 'running' | 'suspended';
+    state: "closed" | "running" | "suspended";
     suspend: () => Promise<void>;
 };
 export declare const createVoiceAudioPlayer: (source: VoiceAudioPlayerSource, options?: VoiceAudioPlayerOptions) => VoiceAudioPlayer;

package/dist/client/bargeInMonitor.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceBargeInMonitor } from "../types";
+export type VoiceBargeInMonitorOptions = {
+    fetch?: typeof fetch;
+    path?: string;
+    thresholdMs?: number;
+};
+export declare const createVoiceBargeInMonitor: (options?: VoiceBargeInMonitorOptions) => VoiceBargeInMonitor;

package/dist/client/browserMedia.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceBrowserMediaReporterOptions, VoiceBrowserMediaReportPayload } from "../types";
+export type VoiceBrowserMediaReporter = {
+    close: () => void;
+    reportOnce: () => Promise<VoiceBrowserMediaReportPayload | undefined>;
+    start: () => void;
+    stop: () => void;
+};
+export declare const createVoiceBrowserMediaReporter: (options: VoiceBrowserMediaReporterOptions) => VoiceBrowserMediaReporter;

package/dist/client/browserNoiseSuppression.d.ts

@@ -0,0 +1,42 @@
+export type BrowserNoiseSuppressorOptions = {
+    /** Existing AudioContext to reuse. If omitted, a fresh one is created at 48kHz. */
+    audioContext?: AudioContext;
+    /** Optional message sent to the worklet via port.postMessage on init. */
+    initialPort?: Record<string, unknown>;
+    /** AudioWorkletNode options forwarded to the constructor. */
+    nodeOptions?: AudioWorkletNodeOptions;
+    /** Registered AudioWorkletProcessor name to instantiate. */
+    processorName: string;
+    /** Caller-supplied input stream from getUserMedia or similar. */
+    stream: MediaStream;
+    /** URL of the AudioWorklet script that registers `processorName`. */
+    workletUrl: string;
+};
+export type BrowserNoiseSuppressorHandle = {
+    /** The worklet node — operators can postMessage to tune at runtime. */
+    node: AudioWorkletNode;
+    /** A MediaStream containing the denoised audio track. */
+    stream: MediaStream;
+    /** Tears down the worklet + closes the AudioContext when this helper created it. */
+    stop: () => Promise<void>;
+};
+export declare const applyBrowserNoiseSuppression: (options: BrowserNoiseSuppressorOptions) => Promise<BrowserNoiseSuppressorHandle>;
+export type BrowserNoiseSuppressorPreset = {
+    initialPort?: Record<string, unknown>;
+    /** Display label for UI affordances. */
+    label: string;
+    nodeOptions?: AudioWorkletNodeOptions;
+    processorName: string;
+    workletUrl: string;
+};
+/**
+ * Convenience presets pointing at well-known open-source worklets. Operators
+ * still install the underlying npm package and copy the worklet file to a
+ * URL their site can serve.
+ */
+export declare const BROWSER_NOISE_SUPPRESSOR_PRESETS: {
+    /** DeepFilterNet 2023 model — best quality open-source pick. */
+    readonly deepfilternet: (workletUrl: string) => BrowserNoiseSuppressorPreset;
+    /** Jitsi @jitsi/rnnoise-wasm — ships a `rnnoise-processor` worklet. */
+    readonly rnnoise: (workletUrl: string) => BrowserNoiseSuppressorPreset;
+};

package/dist/client/browserVoiceSupport.d.ts

@@ -0,0 +1,22 @@
+export type BrowserVoiceSupportProbe = {
+    hasAudioContext: boolean;
+    hasAudioWorklet: boolean;
+    hasGetUserMedia: boolean;
+    hasMediaRecorder: boolean;
+    hasOpusEncoding: boolean;
+    hasRTCPeerConnection: boolean;
+    hasWebSocket: boolean;
+    isInsecureContext: boolean;
+    isIos: boolean;
+    isSafari: boolean;
+    requiresUserGestureToResumeAudio: boolean;
+    userAgent: string;
+};
+export type BrowserVoiceSupportReport = {
+    blockers: string[];
+    capabilities: BrowserVoiceSupportProbe;
+    ok: boolean;
+    warnings: string[];
+};
+export declare const probeBrowserVoiceSupport: (globalScope?: typeof globalThis) => BrowserVoiceSupportProbe;
+export declare const checkBrowserVoiceSupport: (globalScope?: typeof globalThis) => BrowserVoiceSupportReport;

package/dist/client/callDebugger.d.ts

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

package/dist/client/callDebuggerWidget.d.ts

@@ -0,0 +1,30 @@
+import { type VoiceCallDebuggerClientOptions, type VoiceCallDebuggerClientState } from "./callDebugger";
+export type VoiceCallDebuggerLaunchViewModel = {
+    description: string;
+    error: string | null;
+    href: string;
+    isLoading: boolean;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    status: "empty" | "error" | "loading" | "ready" | "warning";
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceCallDebuggerLaunchOptions = VoiceCallDebuggerClientOptions & {
+    description?: string;
+    href?: string | ((input: {
+        report?: VoiceCallDebuggerClientState["report"];
+    }) => string);
+    linkLabel?: string;
+    title?: string;
+};
+export declare const createVoiceCallDebuggerLaunchViewModel: (path: string, state: VoiceCallDebuggerClientState, options?: VoiceCallDebuggerLaunchOptions) => VoiceCallDebuggerLaunchViewModel;
+export declare const renderVoiceCallDebuggerLaunchHTML: (path: string, state: VoiceCallDebuggerClientState, options?: VoiceCallDebuggerLaunchOptions) => string;
+export declare const mountVoiceCallDebuggerLaunch: (element: Element, path: string, options?: VoiceCallDebuggerLaunchOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceCallDebuggerReport | undefined>;
+};
+export declare const defineVoiceCallDebuggerLaunchElement: (tagName?: string) => void;

package/dist/client/callPlayer.d.ts

@@ -0,0 +1,41 @@
+import type { Transcript } from "../types";
+export type VoiceCallPlayerState = {
+    activeTranscriptId?: string;
+    activeTranscriptIndex?: number;
+    audioUrl?: string;
+    buffered: number;
+    currentTimeMs: number;
+    durationMs: number;
+    error?: string;
+    isPlaying: boolean;
+    isReady: boolean;
+    playbackRate: number;
+};
+export type VoiceCallPlayerOptions = {
+    audioUrl?: string;
+    initialPlaybackRate?: number;
+    /** Recording start in epoch ms; used to convert transcript epoch timestamps to playback offsets. */
+    recordingStartedAtEpochMs?: number;
+    transcripts?: ReadonlyArray<Transcript>;
+};
+export type VoiceCallPlayer = {
+    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<Transcript>) => void;
+    subscribe: (listener: () => void) => () => void;
+    transcripts: () => ReadonlyArray<Transcript>;
+};
+export declare const createVoiceCallPlayer: (options?: VoiceCallPlayerOptions) => VoiceCallPlayer;
+export declare const formatVoiceCallPlayerTimestamp: (ms: number) => string;

package/dist/client/campaignDialerProof.d.ts

@@ -0,0 +1,23 @@
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from "../campaignDialers";
+export type VoiceCampaignDialerProofClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    runPath?: string;
+};
+export type VoiceCampaignDialerProofSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceCampaignDialerProofReport;
+    status?: VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};
+export declare const fetchVoiceCampaignDialerProofStatus: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofStatus>;
+export declare const runVoiceCampaignDialerProofAction: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofReport>;
+export declare const createVoiceCampaignDialerProofStore: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/connection.d.ts

@@ -1,8 +1,8 @@
-import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
+import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from "../types";
 type VoiceConnectionHandle = {
     callControl: (message: Omit<VoiceClientMessage & {
-        type: 'call_control';
-    }, 'type'>) => void;
+        type: "call_control";
+    }, "type">) => void;
     start: (input?: {
         sessionId?: string;
         scenarioId?: string;
@@ -14,6 +14,7 @@ type VoiceConnectionHandle = {
     getSessionId: () => string;
     send: (message: VoiceClientMessage) => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     subscribe: (callback: (message: VoiceServerMessage) => void) => () => void;
 };
 export declare const createVoiceConnection: (path: string, options?: VoiceConnectionOptions) => VoiceConnectionHandle;

package/dist/client/controller.d.ts

@@ -1,2 +1,2 @@
-import type { VoiceController, VoiceControllerOptions } from '../types';
+import type { VoiceController, VoiceControllerOptions } from "../types";
 export declare const createVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => VoiceController<TResult>;