@absolutejs/voice 0.0.22-beta.504 → 0.0.22-beta.506

package/dist/angular/voice-call-player.service.d.ts

@@ -0,0 +1,19 @@
+import { type VoiceCallPlayerOptions, type VoiceCallPlayerState } from "../client/callPlayer";
+export type VoiceCallPlayerServiceOptions = VoiceCallPlayerOptions & {
+    title?: string;
+};
+export declare class VoiceCallPlayerService {
+    build(options?: VoiceCallPlayerServiceOptions): {
+        formatTimestamp: (ms: number) => string;
+        pause: () => void;
+        play: () => Promise<void>;
+        seekMs: (ms: number) => void;
+        seekToTranscript: (id: string) => void;
+        setPlaybackRate: (rate: number) => void;
+        setTime: (ms: number) => void;
+        state: import("@angular/core").Signal<VoiceCallPlayerState>;
+        stop: () => void;
+        title: string;
+        transcripts: () => readonly import("..").Transcript[];
+    };
+}

package/dist/assistantExperiment.d.ts

@@ -0,0 +1,41 @@
+import type { DefinedVoiceAssistant } from "./defineVoiceAssistant";
+import type { VoiceSessionRecord } from "./types";
+export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    /** Stable variant id used for trace tagging + rollups. */
+    id: string;
+    /** Relative weight when allocator is 'random' or 'sticky' bucketing. Default 1. */
+    weight?: number;
+    /** The assistant definition produced by defineVoiceAssistant. */
+    assistant: DefinedVoiceAssistant<TContext, TSession, TResult>;
+};
+export type VoiceAssistantAllocatorInput<TContext = unknown> = {
+    context: TContext;
+    sessionId: string;
+    stickyKey?: string;
+};
+export type VoiceAssistantAllocator<TContext = unknown> = (input: VoiceAssistantAllocatorInput<TContext>) => string;
+export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    /** Variant chooser. Default 'sticky' (hash of stickyKey → variant) when stickyKey is present, otherwise 'random'. */
+    allocator?: "random" | "sticky" | VoiceAssistantAllocator<TContext>;
+    /** Stable id for this experiment. Used in trace tagging. */
+    experimentId: string;
+    /** Callback for every allocation decision. Wire to trace.append({ type: 'assistant.experiment' }) for rollups. */
+    onAllocation?: (input: {
+        context: TContext;
+        experimentId: string;
+        sessionId: string;
+        stickyKey?: string;
+        variant: VoiceAssistantVariant<TContext, TSession, TResult>;
+    }) => void;
+    variants: ReadonlyArray<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+export type VoiceAssistantExperimentDecision<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    experimentId: string;
+    variant: VoiceAssistantVariant<TContext, TSession, TResult>;
+};
+export type VoiceAssistantExperiment<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    allocate: (input: VoiceAssistantAllocatorInput<TContext>) => VoiceAssistantExperimentDecision<TContext, TSession, TResult>;
+    experimentId: string;
+    variants: ReadonlyArray<VoiceAssistantVariant<TContext, TSession, TResult>>;
+};
+export declare const createVoiceAssistantExperiment: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAssistantExperimentOptions<TContext, TSession, TResult>) => VoiceAssistantExperiment<TContext, TSession, TResult>;

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/index.d.ts

@@ -110,6 +110,12 @@ export { createInMemoryVoiceCallQuota } from "./callQuota";
 export type { CreateInMemoryVoiceCallQuotaOptions, VoiceCallQuota, VoiceCallQuotaRejection, VoiceCallQuotaResult, VoiceCallQuotaTier, VoiceCallReservation, } from "./callQuota";
 export { createVoiceBearerAuthVerifier, createVoiceHMACAuthVerifier, createVoiceRouteAuth, } from "./routeAuth";
 export type { VoiceRouteAuthDecision, VoiceRouteAuthInput, VoiceRouteAuthOptions, VoiceRouteAuthVerifier, } from "./routeAuth";
+export { createVoiceCallPlayer, formatVoiceCallPlayerTimestamp, } from "./client/callPlayer";
+export type { VoiceCallPlayer, VoiceCallPlayerOptions, VoiceCallPlayerState, } from "./client/callPlayer";
+export { provisionTelnyxPhoneNumber, provisionTwilioPhoneNumber, } from "./phoneProvisioning";
+export type { TelnyxProvisionInput, TwilioProvisionInput, VoicePhoneNumber, } from "./phoneProvisioning";
+export { createVoiceWebhookFanout } from "./webhookFanout";
+export type { VoiceWebhookFanout, VoiceWebhookFanoutEvent, VoiceWebhookFanoutOptions, VoiceWebhookFanoutReport, VoiceWebhookSink, VoiceWebhookSinkDeliveryResult, } from "./webhookFanout";
 export { BROWSER_NOISE_SUPPRESSOR_PRESETS, applyBrowserNoiseSuppression, } from "./client/browserNoiseSuppression";
 export type { BrowserNoiseSuppressorHandle, BrowserNoiseSuppressorOptions, BrowserNoiseSuppressorPreset, } from "./client/browserNoiseSuppression";
 export { buildVoiceHTMXAttributes, wrapVoiceHTMLInHTMXContainer, wrapVoiceHTMLWithHTMXPolling, } from "./client/htmxAttributes";

package/dist/index.js

@@ -36781,6 +36781,397 @@ var createVoiceRouteAuth = (options) => {
     }
   });
 };
+// src/client/callPlayer.ts
+var cloneState = (state) => ({
+  ...state
+});
+var normalizeTranscriptTimes = (transcripts, baseEpoch) => {
+  if (typeof baseEpoch !== "number") {
+    return transcripts;
+  }
+  return transcripts.map((transcript) => {
+    const adjusted = { ...transcript };
+    if (typeof adjusted.startedAtMs === "number" && adjusted.startedAtMs >= baseEpoch) {
+      adjusted.startedAtMs = adjusted.startedAtMs - baseEpoch;
+    }
+    if (typeof adjusted.endedAtMs === "number" && adjusted.endedAtMs >= baseEpoch) {
+      adjusted.endedAtMs = adjusted.endedAtMs - baseEpoch;
+    }
+    return adjusted;
+  });
+};
+var findActiveTranscript = (transcripts, positionMs) => {
+  let candidate;
+  for (let index = 0;index < transcripts.length; index += 1) {
+    const transcript = transcripts[index];
+    if (typeof transcript.startedAtMs !== "number")
+      continue;
+    if (transcript.startedAtMs > positionMs)
+      break;
+    if (typeof transcript.endedAtMs === "number" && transcript.endedAtMs < positionMs) {
+      continue;
+    }
+    candidate = { id: transcript.id, index };
+  }
+  return candidate ?? {};
+};
+var createVoiceCallPlayer = (options = {}) => {
+  let transcripts = normalizeTranscriptTimes(options.transcripts ?? [], options.recordingStartedAtEpochMs);
+  let state = {
+    audioUrl: options.audioUrl,
+    buffered: 0,
+    currentTimeMs: 0,
+    durationMs: 0,
+    isPlaying: false,
+    isReady: false,
+    playbackRate: options.initialPlaybackRate ?? 1
+  };
+  const listeners = new Set;
+  const notify = () => {
+    for (const listener of listeners)
+      listener();
+  };
+  const update = (next) => {
+    state = { ...state, ...next };
+    notify();
+  };
+  const refreshActive = () => {
+    const { id, index } = findActiveTranscript(transcripts, state.currentTimeMs);
+    if (id !== state.activeTranscriptId || index !== state.activeTranscriptIndex) {
+      state = {
+        ...state,
+        activeTranscriptId: id,
+        activeTranscriptIndex: index
+      };
+      notify();
+    }
+  };
+  return {
+    getState: () => cloneState(state),
+    pause: () => {
+      if (!state.isPlaying)
+        return;
+      update({ isPlaying: false });
+    },
+    play: async () => {
+      update({ isPlaying: true });
+    },
+    reset: () => {
+      state = {
+        audioUrl: state.audioUrl,
+        buffered: 0,
+        currentTimeMs: 0,
+        durationMs: 0,
+        isPlaying: false,
+        isReady: false,
+        playbackRate: 1
+      };
+      notify();
+    },
+    seekMs: (positionMs) => {
+      const clamped = Math.max(0, Math.min(state.durationMs || Number.POSITIVE_INFINITY, positionMs));
+      update({ currentTimeMs: clamped });
+      refreshActive();
+    },
+    seekToTranscript: (transcriptId) => {
+      const found = transcripts.find((t) => t.id === transcriptId);
+      if (!found || typeof found.startedAtMs !== "number") {
+        return;
+      }
+      update({ currentTimeMs: Math.max(0, found.startedAtMs) });
+      refreshActive();
+    },
+    setAudioUrl: (url) => {
+      update({ audioUrl: url, isReady: false });
+    },
+    setBuffered: (seconds) => {
+      update({ buffered: Math.max(0, seconds) });
+    },
+    setDuration: (durationMs) => {
+      update({ durationMs: Math.max(0, durationMs) });
+    },
+    setError: (error) => {
+      update({ error });
+    },
+    setPlaybackRate: (rate5) => {
+      update({ playbackRate: Math.max(0.25, Math.min(4, rate5)) });
+    },
+    setPlaying: (playing) => {
+      if (playing === state.isPlaying)
+        return;
+      update({ isPlaying: playing });
+    },
+    setReady: (ready) => {
+      update({ isReady: ready });
+    },
+    setTime: (positionMs) => {
+      const next = Math.max(0, positionMs);
+      if (next === state.currentTimeMs)
+        return;
+      update({ currentTimeMs: next });
+      refreshActive();
+    },
+    setTranscripts: (next) => {
+      transcripts = normalizeTranscriptTimes(next, options.recordingStartedAtEpochMs);
+      refreshActive();
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    transcripts: () => transcripts
+  };
+};
+var formatVoiceCallPlayerTimestamp = (ms) => {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  const minutes = Math.floor(seconds / 60);
+  const remaining = seconds % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(remaining).padStart(2, "0")}`;
+};
+// src/phoneProvisioning.ts
+var requireAuth = (input) => {
+  if (!input.accountSid || !input.authToken) {
+    throw new Error("Twilio provisioning requires accountSid + authToken");
+  }
+};
+var toBasicAuth = (sid, token) => `Basic ${btoa(`${sid}:${token}`)}`;
+var searchTwilioCandidate = async (input) => {
+  const fetchImpl = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const country = input.countryCode ?? "US";
+  const url = new URL(`https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(input.accountSid)}/AvailablePhoneNumbers/${encodeURIComponent(country)}/Local.json`);
+  if (input.areaCode)
+    url.searchParams.set("AreaCode", input.areaCode);
+  if (input.contains)
+    url.searchParams.set("Contains", input.contains);
+  url.searchParams.set("PageSize", "5");
+  const response = await fetchImpl(url, {
+    headers: {
+      accept: "application/json",
+      authorization: toBasicAuth(input.accountSid, input.authToken)
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Twilio AvailablePhoneNumbers failed: ${response.status} ${response.statusText} ${body.slice(0, 200)}`);
+  }
+  const payload = await response.json();
+  const candidate = payload.available_phone_numbers?.[0]?.phone_number;
+  if (!candidate) {
+    throw new Error("Twilio returned no available phone numbers for the query");
+  }
+  return candidate;
+};
+var provisionTwilioPhoneNumber = async (input) => {
+  requireAuth(input);
+  const fetchImpl = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const phoneNumber = await searchTwilioCandidate(input);
+  const body = new URLSearchParams;
+  body.set("PhoneNumber", phoneNumber);
+  body.set("VoiceUrl", input.voiceUrl);
+  if (input.friendlyName)
+    body.set("FriendlyName", input.friendlyName);
+  if (input.statusCallbackUrl)
+    body.set("StatusCallback", input.statusCallbackUrl);
+  if (input.smsUrl)
+    body.set("SmsUrl", input.smsUrl);
+  const purchaseUrl = `https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(input.accountSid)}/IncomingPhoneNumbers.json`;
+  const response = await fetchImpl(purchaseUrl, {
+    body: body.toString(),
+    headers: {
+      accept: "application/json",
+      authorization: toBasicAuth(input.accountSid, input.authToken),
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Twilio IncomingPhoneNumbers POST failed: ${response.status} ${response.statusText} ${text.slice(0, 200)}`);
+  }
+  const result = await response.json();
+  return {
+    phoneNumber: result.phone_number,
+    provider: "twilio",
+    providerNumberId: result.sid,
+    raw: result
+  };
+};
+var provisionTelnyxPhoneNumber = async (input) => {
+  if (!input.apiKey) {
+    throw new Error("Telnyx provisioning requires apiKey");
+  }
+  const fetchImpl = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const searchUrl = new URL("https://api.telnyx.com/v2/available_phone_numbers");
+  searchUrl.searchParams.set("filter[country_code]", input.countryCode ?? "US");
+  searchUrl.searchParams.set("filter[features]", "voice");
+  if (input.areaCode) {
+    searchUrl.searchParams.set("filter[national_destination_code]", input.areaCode);
+  }
+  searchUrl.searchParams.set("filter[limit]", "5");
+  const searchResponse = await fetchImpl(searchUrl, {
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${input.apiKey}`
+    }
+  });
+  if (!searchResponse.ok) {
+    const text = await searchResponse.text().catch(() => "");
+    throw new Error(`Telnyx available_phone_numbers failed: ${searchResponse.status} ${text.slice(0, 200)}`);
+  }
+  const searchPayload = await searchResponse.json();
+  const candidate = searchPayload.data?.[0]?.phone_number;
+  if (!candidate) {
+    throw new Error("Telnyx returned no available phone numbers for the query");
+  }
+  const orderBody = {
+    phone_numbers: [{ phone_number: candidate }]
+  };
+  if (input.connectionId)
+    orderBody.connection_id = input.connectionId;
+  if (input.messagingProfileId)
+    orderBody.messaging_profile_id = input.messagingProfileId;
+  const orderResponse = await fetchImpl("https://api.telnyx.com/v2/number_orders", {
+    body: JSON.stringify(orderBody),
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${input.apiKey}`,
+      "content-type": "application/json"
+    },
+    method: "POST"
+  });
+  if (!orderResponse.ok) {
+    const text = await orderResponse.text().catch(() => "");
+    throw new Error(`Telnyx number_orders POST failed: ${orderResponse.status} ${text.slice(0, 200)}`);
+  }
+  const orderResult = await orderResponse.json();
+  const orderedNumber = orderResult.data?.phone_numbers?.[0]?.phone_number ?? candidate;
+  const phoneNumberId = orderResult.data?.phone_numbers?.[0]?.id ?? orderResult.data?.id ?? "";
+  if (phoneNumberId) {
+    const updateResponse = await fetchImpl(`https://api.telnyx.com/v2/phone_numbers/${encodeURIComponent(phoneNumberId)}`, {
+      body: JSON.stringify({
+        voice: { webhook_url: input.voiceWebhookUrl }
+      }),
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${input.apiKey}`,
+        "content-type": "application/json"
+      },
+      method: "PATCH"
+    });
+    if (!updateResponse.ok) {
+      const text = await updateResponse.text().catch(() => "");
+      throw new Error(`Telnyx phone_numbers PATCH failed: ${updateResponse.status} ${text.slice(0, 200)}`);
+    }
+  }
+  return {
+    phoneNumber: orderedNumber,
+    provider: "telnyx",
+    providerNumberId: phoneNumberId,
+    raw: orderResult
+  };
+};
+// src/webhookFanout.ts
+var deliverOnce = async (input) => {
+  const startedAt = Date.now();
+  const timeoutMs = input.sink.timeoutMs ?? 1e4;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const headers = {
+    "content-type": "application/json",
+    ...input.sink.headers
+  };
+  if (input.sink.signingSecret) {
+    const timestamp = String(Date.now());
+    headers["x-absolutejs-timestamp"] = timestamp;
+    headers["x-absolutejs-signature"] = await signVoiceWebhookBody({
+      body: input.body,
+      secret: input.sink.signingSecret,
+      timestamp
+    });
+  }
+  try {
+    const response = await input.fetchImpl(input.sink.url, {
+      body: input.body,
+      headers,
+      method: "POST",
+      signal: controller.signal
+    });
+    const durationMs = Date.now() - startedAt;
+    if (!response.ok) {
+      return {
+        attempt: 0,
+        durationMs,
+        error: `HTTP ${response.status}`,
+        ok: false,
+        sinkId: input.sink.id,
+        status: response.status
+      };
+    }
+    return {
+      attempt: 0,
+      durationMs,
+      ok: true,
+      sinkId: input.sink.id,
+      status: response.status
+    };
+  } catch (error) {
+    return {
+      attempt: 0,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error),
+      ok: false,
+      sinkId: input.sink.id
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var sleep6 = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var deliverWithRetry = async (input) => {
+  const maxRetries = input.sink.maxRetries ?? 3;
+  const backoffMs = input.sink.backoffMs ?? 1000;
+  let last;
+  for (let attempt = 1;attempt <= maxRetries; attempt += 1) {
+    last = await deliverOnce(input);
+    last.attempt = attempt;
+    if (last.ok) {
+      return last;
+    }
+    if (attempt < maxRetries) {
+      await sleep6(backoffMs * attempt);
+    }
+  }
+  return last ?? {
+    attempt: 0,
+    durationMs: 0,
+    error: "no attempts ran",
+    ok: false,
+    sinkId: input.sink.id
+  };
+};
+var createVoiceWebhookFanout = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+  return {
+    deliver: async (event) => {
+      const body = JSON.stringify({
+        payload: event.payload,
+        type: event.type
+      });
+      const matching = options.sinks.filter((sink) => sink.acceptEvent ? sink.acceptEvent(event) : true);
+      const deliveries = await Promise.all(matching.map((sink) => deliverWithRetry({ body, fetchImpl, sink })));
+      const succeeded = deliveries.filter((d) => d.ok).length;
+      return {
+        deliveries,
+        failed: deliveries.length - succeeded,
+        succeeded
+      };
+    }
+  };
+};
 // src/client/browserNoiseSuppression.ts
 var isBrowser = () => typeof window !== "undefined" && typeof window.AudioContext !== "undefined";
 var applyBrowserNoiseSuppression = async (options) => {
@@ -39812,7 +40203,7 @@ var getMessageToolCalls = (message) => {
   return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
 };
 var createHTTPError = (provider, response) => new Error(`${provider} voice assistant model failed: HTTP ${response.status}`);
-var sleep6 = (ms) => new Promise((resolve2) => {
+var sleep7 = (ms) => new Promise((resolve2) => {
   setTimeout(resolve2, ms);
 });
 var errorMessage = (error) => error instanceof Error ? error.message : String(error);
@@ -40526,7 +40917,7 @@ var createGeminiVoiceAssistantModel = (options) => {
           break;
         }
         const retryAfter = Number(response.headers.get("retry-after"));
-        await sleep6(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt);
+        await sleep7(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt);
       }
       if (!response) {
         throw new Error("Gemini voice assistant model failed: no response");
@@ -47861,6 +48252,8 @@ export {
   purgeVoiceRetentionStore,
   pruneVoiceTraceEvents,
   pruneVoiceIncidentBundleArtifacts,
+  provisionTwilioPhoneNumber,
+  provisionTelnyxPhoneNumber,
   parseVoiceTelephonyWebhookEvent,
   parseVoiceSessionSnapshot,
   normalizeVoiceProofTrendReport,
@@ -47890,6 +48283,7 @@ export {
   getDefaultVoiceTelephonyBenchmarkScenarios,
   fromVapiAssistantConfig,
   formatVoiceProofTrendAge,
+  formatVoiceCallPlayerTimestamp,
   filterVoiceTraceEvents,
   filterVoiceAuditEvents,
   fetchVoiceProofTarget,
@@ -47963,6 +48357,7 @@ export {
   createVoiceWorkflowContractHandler,
   createVoiceWorkflowContract,
   createVoiceWebhookHandoffAdapter,
+  createVoiceWebhookFanout,
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
   createVoiceWebhookDeliverySink,
@@ -48258,6 +48653,7 @@ export {
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
+  createVoiceCallPlayer,
   createVoiceCallDebuggerRoutes,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,

package/dist/phoneProvisioning.d.ts

@@ -0,0 +1,29 @@
+export type VoicePhoneNumber = {
+    phoneNumber: string;
+    provider: "telnyx" | "twilio" | (string & {});
+    providerNumberId: string;
+    raw: unknown;
+};
+export type TwilioProvisionInput = {
+    accountSid: string;
+    areaCode?: string;
+    authToken: string;
+    contains?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    friendlyName?: string;
+    smsUrl?: string;
+    statusCallbackUrl?: string;
+    voiceUrl: string;
+};
+export declare const provisionTwilioPhoneNumber: (input: TwilioProvisionInput) => Promise<VoicePhoneNumber>;
+export type TelnyxProvisionInput = {
+    apiKey: string;
+    areaCode?: string;
+    connectionId?: string;
+    countryCode?: string;
+    fetch?: typeof fetch;
+    messagingProfileId?: string;
+    voiceWebhookUrl: string;
+};
+export declare const provisionTelnyxPhoneNumber: (input: TelnyxProvisionInput) => Promise<VoicePhoneNumber>;

package/dist/react/VoiceCallPlayer.d.ts

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

package/dist/react/index.d.ts

@@ -37,6 +37,8 @@ export { useVoiceStream } from "./useVoiceStream";
 export { useVoiceController } from "./useVoiceController";
 export { VoiceWidget } from "./VoiceWidget";
 export type { VoiceWidgetLabels, VoiceWidgetProps, VoiceWidgetTheme, } from "./VoiceWidget";
+export { VoiceCallPlayer } from "./VoiceCallPlayer";
+export type { VoiceCallPlayerProps } from "./VoiceCallPlayer";
 export { VoiceCostDashboard } from "./VoiceCostDashboard";
 export type { VoiceCostDashboardProps } from "./VoiceCostDashboard";
 export { VoiceLiveCallViewer } from "./VoiceLiveCallViewer";