@absolutejs/voice 0.0.22-beta.66 → 0.0.22-beta.660

package/dist/testing/ioProviderSimulator.d.ts

@@ -1,13 +1,13 @@
-import type { VoiceIOProviderRouterEvent } from '../providerAdapters';
-export type VoiceIOProviderFailureSimulationMode = 'failure' | 'recovery';
-export type VoiceIOProviderFailureSimulationKind = 'stt' | 'tts';
-export type VoiceIOProviderFailureSimulationOperation = 'open' | 'send';
+import type { VoiceIOProviderRouterEvent } from "../core/providerAdapters";
+export type VoiceIOProviderFailureSimulationMode = "failure" | "recovery";
+export type VoiceIOProviderFailureSimulationKind = "stt" | "tts";
+export type VoiceIOProviderFailureSimulationOperation = "open" | "send";
 export type VoiceIOProviderFailureSimulationResult<TProvider extends string = string> = {
     fallbackProvider?: TProvider;
     mode: VoiceIOProviderFailureSimulationMode;
     provider: TProvider;
     sessionId: string;
-    status: 'simulated';
+    status: "simulated";
     suppressedUntil?: number;
 };
 export type VoiceIOProviderFailureSimulatorOptions<TProvider extends string = string> = {

package/dist/testing/outcomes.d.ts

@@ -0,0 +1,12 @@
+import type { VoiceSTTBenchmarkFixtureResult } from "./benchmark";
+export type VoiceBenchmarkOutcomeSummary = {
+    completeRequiredProfileRate: number;
+    costPerPassingFixture?: number;
+    fixtureCount: number;
+    passingFixtureCount: number;
+    requiredFieldAccuracy: number;
+    totalCost?: number;
+};
+export declare const summarizeVoiceBenchmarkOutcomes: (fixtures: VoiceSTTBenchmarkFixtureResult[], costs?: {
+    total: number;
+}) => VoiceBenchmarkOutcomeSummary;

package/dist/testing/provenance.d.ts

@@ -0,0 +1,44 @@
+export type VoiceBenchmarkPromptTrack = "unprompted" | "production-context" | "oracle-seeded";
+export type VoiceCorpusSplit = "development" | "public-test" | "private-held-out";
+export type VoiceCorpusFixtureProvenance = {
+    audioSha256: string;
+    consent?: string;
+    fixtureId: string;
+    license: string;
+    licenseClass: "permissive" | "noncommercial" | "private";
+    source: string;
+    split: VoiceCorpusSplit;
+};
+export type VoiceBenchmarkRunManifest = {
+    adapter: {
+        id: string;
+        model?: string;
+        provider?: string;
+        version?: string;
+    };
+    corpus: {
+        fixtures: VoiceCorpusFixtureProvenance[];
+        manifestSha256: string;
+        name: string;
+        version: string;
+    };
+    createdAt: string;
+    environment: Record<string, string | number | boolean>;
+    git: Record<string, string>;
+    preprocessing: Record<string, unknown>;
+    pricing?: Record<string, number>;
+    promptTrack: VoiceBenchmarkPromptTrack;
+    seed: number;
+};
+export declare const sha256Bytes: (value: Uint8Array | string) => string;
+export declare const stableBenchmarkJson: (value: unknown) => string;
+export declare const buildVoiceBenchmarkArtifact: <T>(manifest: VoiceBenchmarkRunManifest, report: T) => {
+    artifactSha256: string;
+    manifest: VoiceBenchmarkRunManifest;
+    report: T;
+};
+export declare const verifyVoiceBenchmarkArtifact: (artifact: {
+    artifactSha256: string;
+    manifest: VoiceBenchmarkRunManifest;
+    report: unknown;
+}) => boolean;

package/dist/testing/providerSimulator.d.ts

@@ -1,7 +1,7 @@
-import type { VoiceAgentModelInput, VoiceAgentModelOutput } from '../agent';
-import type { VoiceSessionRecord } from '../types';
-import type { VoiceProviderRouterEvent, VoiceProviderRouterHealthOptions } from '../modelAdapters';
-export type VoiceProviderFailureSimulationMode = 'failure' | 'recovery';
+import type { VoiceAgentModelInput, VoiceAgentModelOutput } from "../core/agent";
+import type { VoiceSessionRecord } from "../core/types";
+import type { VoiceProviderRouterEvent, VoiceProviderRouterHealthOptions } from "../core/modelAdapters";
+export type VoiceProviderFailureSimulationMode = "failure" | "recovery";
 export type VoiceProviderFailureSimulationContext<TProvider extends string = string> = {
     query: {
         provider: TProvider;
@@ -15,7 +15,7 @@ export type VoiceProviderFailureSimulationResult<TProvider extends string = stri
     replayHref?: string;
     result: VoiceAgentModelOutput<TResult>;
     sessionId: string;
-    status: 'simulated';
+    status: "simulated";
     turnId: string;
 };
 type ProviderListResolver<TContext, TSession extends VoiceSessionRecord, TProvider extends string> = readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);

package/dist/testing/review.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceCallDisposition, VoiceServerMessage } from '../types';
-type ReviewTimelineSource = 'benchmark' | 'stt' | 'turn' | 'twilio';
+import type { VoiceCallDisposition, VoiceServerMessage } from "../core/types";
+type ReviewTimelineSource = "benchmark" | "stt" | "turn" | "twilio";
 export type VoiceCallReviewTimelineEvent = {
     atMs: number;
     event: string;
@@ -113,7 +113,7 @@ export type VoiceCallReviewRecorder = {
     recordTwilioInbound: (input: {
         bytes?: number;
         chunkDurationMs?: number;
-        event: 'connected' | 'mark' | 'media' | 'start' | 'stop';
+        event: "connected" | "mark" | "media" | "start" | "stop";
         name?: string;
         reason?: string;
         text?: string;
@@ -122,7 +122,7 @@ export type VoiceCallReviewRecorder = {
     recordTwilioOutbound: (input: {
         bytes?: number;
         chunkDurationMs?: number;
-        event: 'clear' | 'mark' | 'media';
+        event: "clear" | "mark" | "media";
         name?: string;
         reason?: string;
         text?: string;
@@ -130,14 +130,14 @@ export type VoiceCallReviewRecorder = {
     }) => void;
     recordVoiceMessage: (message: VoiceServerMessage) => void;
 };
-export declare const withVoiceCallReviewId: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
-    id: string;
-};
 export declare const createVoiceCallReviewFromLiveTelephonyReport: (report: LiveTelephonyReviewInput, options?: {
     path?: string;
     preset?: string;
 }) => VoiceCallReviewArtifact;
+export declare const withVoiceCallReviewId: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
+    id: string;
+};
 export declare const createVoiceCallReviewRecorder: (options?: VoiceCallReviewRecorderOptions) => VoiceCallReviewRecorder;
-export declare const renderVoiceCallReviewMarkdown: (artifact: VoiceCallReviewArtifact) => string;
 export declare const renderVoiceCallReviewHTML: (artifact: VoiceCallReviewArtifact) => string;
+export declare const renderVoiceCallReviewMarkdown: (artifact: VoiceCallReviewArtifact) => string;
 export {};

package/dist/testing/routingBenchmark.d.ts

@@ -0,0 +1,16 @@
+export type VoiceSTTRoutingFixture = {
+    fallbackScore: number;
+    fallbackUsed: boolean;
+    id: string;
+    primaryScore: number;
+};
+export type VoiceSTTRoutingBenchmarkReport = {
+    fallbackAttemptRate: number;
+    fallbackHarmRate: number;
+    fallbackImprovementRate: number;
+    fixtureCount: number;
+    oracleScore: number;
+    primaryScore: number;
+    selectedScore: number;
+};
+export declare const evaluateVoiceSTTRouting: (fixtures: VoiceSTTRoutingFixture[]) => VoiceSTTRoutingBenchmarkReport;

package/dist/testing/sessionBenchmark.d.ts

@@ -1,6 +1,6 @@
-import type { STTAdapter, VoiceAudioConditioningConfig, VoicePhraseHint, VoiceSTTFallbackConfig, VoiceSTTLifecycle, VoiceTurnCorrectionHandler, VoiceTurnProfile, VoiceTranscriptQuality } from '../types';
-import { type VoiceTranscriptAccuracy } from './accuracy';
-import type { VoiceTestFixture } from './fixtures';
+import type { STTAdapter, VoiceAudioConditioningConfig, VoicePhraseHint, VoiceSTTFallbackConfig, VoiceSTTLifecycle, VoiceTurnCorrectionHandler, VoiceTurnProfile, VoiceTranscriptQuality } from "../core/types";
+import { type VoiceTranscriptAccuracy } from "./accuracy";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceSessionBenchmarkScenario = VoiceTestFixture & {
     expectedTurnTexts: string[];
     phraseHints?: VoicePhraseHint[];
@@ -117,16 +117,6 @@ export type VoiceSessionBenchmarkSeriesReport = {
     scenarios: VoiceSessionBenchmarkScenarioAggregate[];
     summary: VoiceSessionBenchmarkSeriesSummary;
 };
-export declare const runVoiceSessionBenchmarkScenario: (adapter: STTAdapter, fixture: VoiceSessionBenchmarkScenario, options?: {
-    correctTurn?: VoiceTurnCorrectionHandler;
-    sttFallback?: VoiceSTTFallbackConfig;
-    trace?: boolean;
-}) => Promise<VoiceSessionBenchmarkScenarioResult>;
-export declare const summarizeVoiceSessionBenchmark: (adapterId: string, scenarios: VoiceSessionBenchmarkScenarioResult[]) => VoiceSessionBenchmarkSummary;
-export declare const summarizeVoiceSessionBenchmarkSeries: (input: {
-    adapterId: string;
-    reports: VoiceSessionBenchmarkReport[];
-}) => VoiceSessionBenchmarkSeriesReport;
 export declare const runVoiceSessionBenchmark: (input: {
     adapter: STTAdapter;
     adapterId: string;
@@ -140,6 +130,11 @@ export declare const runVoiceSessionBenchmark: (input: {
     scenarios: VoiceSessionBenchmarkScenarioResult[];
     summary: VoiceSessionBenchmarkSummary;
 }>;
+export declare const runVoiceSessionBenchmarkScenario: (adapter: STTAdapter, fixture: VoiceSessionBenchmarkScenario, options?: {
+    correctTurn?: VoiceTurnCorrectionHandler;
+    sttFallback?: VoiceSTTFallbackConfig;
+    trace?: boolean;
+}) => Promise<VoiceSessionBenchmarkScenarioResult>;
 export declare const runVoiceSessionBenchmarkSeries: (input: {
     adapter: STTAdapter;
     adapterId: string;
@@ -149,3 +144,8 @@ export declare const runVoiceSessionBenchmarkSeries: (input: {
     sttFallback?: VoiceSTTFallbackConfig;
     trace?: boolean;
 }) => Promise<VoiceSessionBenchmarkSeriesReport>;
+export declare const summarizeVoiceSessionBenchmark: (adapterId: string, scenarios: VoiceSessionBenchmarkScenarioResult[]) => VoiceSessionBenchmarkSummary;
+export declare const summarizeVoiceSessionBenchmarkSeries: (input: {
+    adapterId: string;
+    reports: VoiceSessionBenchmarkReport[];
+}) => VoiceSessionBenchmarkSeriesReport;

package/dist/testing/statistics.d.ts

@@ -0,0 +1,30 @@
+import type { VoiceTranscriptAccuracy } from "./accuracy";
+export type VoiceAggregateErrorMetrics = {
+    correct: number;
+    deletions: number;
+    insertions: number;
+    macroWordErrorRate: number;
+    microWordErrorRate: number;
+    referenceWordCount: number;
+    sentenceErrorRate: number;
+    substitutions: number;
+};
+export type VoiceConfidenceInterval = {
+    confidenceLevel: number;
+    high: number;
+    low: number;
+    samples: number;
+};
+export type VoicePairedBootstrapComparison = {
+    baselineMean: number;
+    candidateMean: number;
+    delta: number;
+    deltaConfidenceInterval: VoiceConfidenceInterval;
+    probabilityCandidateIsBetter: number;
+};
+export declare const aggregateTranscriptAccuracy: (values: VoiceTranscriptAccuracy[]) => VoiceAggregateErrorMetrics;
+export declare const comparePairedMetrics: (baseline: number[], candidate: number[], options?: {
+    confidenceLevel?: number;
+    samples?: number;
+    seed?: number;
+}) => VoicePairedBootstrapComparison;

package/dist/testing/stt.d.ts

@@ -1,6 +1,6 @@
-import { type VoiceTranscriptAccuracy } from './accuracy';
-import type { STTAdapter, STTAdapterOpenOptions, VoiceCloseEvent, VoiceEndOfTurnEvent, VoiceErrorEvent, VoiceFinalEvent, VoicePartialEvent } from '../types';
-import type { VoiceTestFixture } from './fixtures';
+import { type VoiceTranscriptAccuracy } from "./accuracy";
+import type { STTAdapter, STTAdapterOpenOptions, VoiceCloseEvent, VoiceEndOfTurnEvent, VoiceErrorEvent, VoiceFinalEvent, VoicePartialEvent } from "../core/types";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceSTTAdapterHarnessOptions = {
     chunkDurationMs?: number;
     idleTimeoutMs?: number;

package/dist/testing/telephony.d.ts

@@ -1,3 +1,5 @@
+import { type VoiceOperationsRecord } from "../core/operationsRecord";
+import { type VoiceTraceEventStore } from "../core/trace";
 export type VoiceTelephonyBenchmarkScenario = {
     expectClear: boolean;
     expectMark: boolean;
@@ -40,6 +42,28 @@ export type VoiceTelephonyBenchmarkReport = {
     generatedAt: number;
     summary: VoiceTelephonyBenchmarkSummary;
 };
+export type VoiceTelephonyMediaOperationsSmokeOptions = {
+    callSid?: string;
+    operationsRecordHref?: string | ((input: {
+        sessionId: string;
+        streamSid: string;
+    }) => string);
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    streamSid?: string;
+    timeoutMs?: number;
+};
+export type VoiceTelephonyMediaOperationsSmokeReport = {
+    issues: string[];
+    ok: boolean;
+    operationsRecord: VoiceOperationsRecord;
+    operationsRecordHref?: string;
+    sentEvents: string[];
+    sessionId: string;
+    streamSid: string;
+    telephonyMedia: VoiceOperationsRecord["telephonyMedia"];
+};
 type VoiceTelephonyBenchmarkOptions = {
     timeoutMs?: number;
 };
@@ -54,8 +78,6 @@ export declare const getDefaultVoiceTelephonyBenchmarkScenarios: () => {
     ttsChunkCount?: number;
     ttsChunkDelayMs?: number;
 }[];
-export declare const runVoiceTelephonyBenchmarkScenario: (scenario: VoiceTelephonyBenchmarkScenario, options?: VoiceTelephonyBenchmarkOptions) => Promise<VoiceTelephonyBenchmarkScenarioResult>;
-export declare const summarizeVoiceTelephonyBenchmark: (fixtures: VoiceTelephonyBenchmarkScenarioResult[]) => VoiceTelephonyBenchmarkSummary;
 export declare const runVoiceTelephonyBenchmark: (scenarios?: {
     expectClear: boolean;
     expectMark: boolean;
@@ -67,4 +89,7 @@ export declare const runVoiceTelephonyBenchmark: (scenarios?: {
     ttsChunkCount?: number;
     ttsChunkDelayMs?: number;
 }[], options?: VoiceTelephonyBenchmarkOptions) => Promise<VoiceTelephonyBenchmarkReport>;
+export declare const runVoiceTelephonyBenchmarkScenario: (scenario: VoiceTelephonyBenchmarkScenario, options?: VoiceTelephonyBenchmarkOptions) => Promise<VoiceTelephonyBenchmarkScenarioResult>;
+export declare const runVoiceTelephonyMediaOperationsSmoke: (options?: VoiceTelephonyMediaOperationsSmokeOptions) => Promise<VoiceTelephonyMediaOperationsSmokeReport>;
+export declare const summarizeVoiceTelephonyBenchmark: (fixtures: VoiceTelephonyBenchmarkScenarioResult[]) => VoiceTelephonyBenchmarkSummary;
 export {};

package/dist/testing/tts.d.ts

@@ -1,4 +1,4 @@
-import type { AudioFormat, RealtimeAdapter, RealtimeAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from '../types';
+import type { AudioFormat, RealtimeAdapter, RealtimeAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from "../core/types";
 export type VoiceTTSBenchmarkFixture = {
     id: string;
     tags?: string[];
@@ -62,12 +62,12 @@ export declare const getDefaultTTSBenchmarkFixtures: () => {
     text: string;
     title: string;
 }[];
-export declare const runTTSAdapterFixture: (adapter: VoiceOutputAdapter, fixture: VoiceTTSBenchmarkFixture, options?: VoiceTTSBenchmarkOptions) => Promise<VoiceTTSBenchmarkFixtureResult>;
 export declare const runTTSAdapterBenchmark: (adapterId: string, adapter: VoiceOutputAdapter, fixtures?: {
     id: string;
     tags?: string[];
     text: string;
     title: string;
 }[], options?: VoiceTTSBenchmarkOptions) => Promise<VoiceTTSBenchmarkReport>;
+export declare const runTTSAdapterFixture: (adapter: VoiceOutputAdapter, fixture: VoiceTTSBenchmarkFixture, options?: VoiceTTSBenchmarkOptions) => Promise<VoiceTTSBenchmarkFixtureResult>;
 export declare const summarizeTTSBenchmark: (adapterId: string, fixtures: VoiceTTSBenchmarkFixtureResult[]) => VoiceTTSBenchmarkSummary;
 export {};

package/dist/vue/VoiceCallDebuggerLaunch.d.ts

@@ -0,0 +1,72 @@
+import { type PropType } from "vue";
+import type { VoiceReactiveSource } from "../client/reactiveSource";
+export declare const VoiceCallDebuggerLaunch: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        default: string;
+        type: StringConstructor;
+    };
+    description: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    href: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    intervalMs: {
+        default: number;
+        type: NumberConstructor;
+    };
+    reactiveSource: PropType<VoiceReactiveSource>;
+    linkLabel: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    path: {
+        required: true;
+        type: StringConstructor;
+    };
+    title: {
+        default: undefined;
+        type: StringConstructor;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        default: string;
+        type: StringConstructor;
+    };
+    description: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    href: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    intervalMs: {
+        default: number;
+        type: NumberConstructor;
+    };
+    reactiveSource: PropType<VoiceReactiveSource>;
+    linkLabel: {
+        default: undefined;
+        type: StringConstructor;
+    };
+    path: {
+        required: true;
+        type: StringConstructor;
+    };
+    title: {
+        default: undefined;
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {
+    description: string;
+    title: string;
+    href: string;
+    intervalMs: number;
+    linkLabel: string;
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceCallPlayer.d.ts

@@ -0,0 +1,40 @@
+import { type PropType } from "vue";
+import { type VoiceCallPlayer as VoiceCallPlayerHandle } from "../client/callPlayer";
+import type { Transcript } from "../core/types";
+export declare const VoiceCallPlayer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    audioUrl: StringConstructor;
+    player: {
+        default: undefined;
+        type: PropType<VoiceCallPlayerHandle | undefined>;
+    };
+    recordingStartedAtEpochMs: NumberConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    transcripts: {
+        default: () => never[];
+        type: PropType<ReadonlyArray<Transcript>>;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    audioUrl: StringConstructor;
+    player: {
+        default: undefined;
+        type: PropType<VoiceCallPlayerHandle | undefined>;
+    };
+    recordingStartedAtEpochMs: NumberConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    transcripts: {
+        default: () => never[];
+        type: PropType<ReadonlyArray<Transcript>>;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    transcripts: readonly Transcript[];
+    player: VoiceCallPlayerHandle | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceCostDashboard.d.ts

@@ -0,0 +1,57 @@
+import { type PropType } from "vue";
+import type { StoredVoiceTraceEvent } from "../core/trace";
+import { type VoiceCostDashboardOptions } from "../client/costDashboard";
+export declare const VoiceCostDashboard: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    bucketBy: {
+        default: string;
+        type: PropType<VoiceCostDashboardOptions["bucketBy"]>;
+    };
+    currency: {
+        default: string;
+        type: StringConstructor;
+    };
+    emptyMessage: {
+        default: string;
+        type: StringConstructor;
+    };
+    events: {
+        required: true;
+        type: PropType<ReadonlyArray<StoredVoiceTraceEvent>>;
+    };
+    fromMs: NumberConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    toMs: NumberConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    bucketBy: {
+        default: string;
+        type: PropType<VoiceCostDashboardOptions["bucketBy"]>;
+    };
+    currency: {
+        default: string;
+        type: StringConstructor;
+    };
+    emptyMessage: {
+        default: string;
+        type: StringConstructor;
+    };
+    events: {
+        required: true;
+        type: PropType<ReadonlyArray<StoredVoiceTraceEvent>>;
+    };
+    fromMs: NumberConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    toMs: NumberConstructor;
+}>> & Readonly<{}>, {
+    title: string;
+    currency: string;
+    emptyMessage: string;
+    bucketBy: "day" | "hour" | "month" | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceDeliveryRuntime.d.ts

@@ -0,0 +1,34 @@
+import { type PropType } from "vue";
+import type { VoiceReactiveSource } from "../client/reactiveSource";
+export declare const VoiceDeliveryRuntime: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    description: StringConstructor;
+    includeActions: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    intervalMs: NumberConstructor;
+    path: {
+        default: string;
+        type: StringConstructor;
+    };
+    reactiveSource: PropType<VoiceReactiveSource>;
+    title: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    description: StringConstructor;
+    includeActions: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    intervalMs: NumberConstructor;
+    path: {
+        default: string;
+        type: StringConstructor;
+    };
+    reactiveSource: PropType<VoiceReactiveSource>;
+    title: StringConstructor;
+}>> & Readonly<{}>, {
+    path: string;
+    includeActions: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceLiveAgentConsole.d.ts

@@ -0,0 +1,50 @@
+import { type PropType } from "vue";
+import { type LiveAgentConsole } from "../client/liveAgentConsole";
+export declare const VoiceLiveAgentConsole: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    console: {
+        default: undefined;
+        type: PropType<LiveAgentConsole | undefined>;
+    };
+    sessionId: {
+        default: string;
+        type: StringConstructor;
+    };
+    takeoverButtonLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    takeoverReason: StringConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    takeover: (_reason?: string) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    console: {
+        default: undefined;
+        type: PropType<LiveAgentConsole | undefined>;
+    };
+    sessionId: {
+        default: string;
+        type: StringConstructor;
+    };
+    takeoverButtonLabel: {
+        default: string;
+        type: StringConstructor;
+    };
+    takeoverReason: StringConstructor;
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    onTakeover?: ((_reason?: string | undefined) => any) | undefined;
+}>, {
+    title: string;
+    sessionId: string;
+    console: LiveAgentConsole | undefined;
+    takeoverButtonLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceLiveCallViewer.d.ts

@@ -0,0 +1,35 @@
+import { type PropType } from "vue";
+import { type LiveCallViewer } from "../client/liveCallViewer";
+export declare const VoiceLiveCallViewer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    sessionId: {
+        default: string;
+        type: StringConstructor;
+    };
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    viewer: {
+        default: undefined;
+        type: PropType<LiveCallViewer | undefined>;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    sessionId: {
+        default: string;
+        type: StringConstructor;
+    };
+    title: {
+        default: string;
+        type: StringConstructor;
+    };
+    viewer: {
+        default: undefined;
+        type: PropType<LiveCallViewer | undefined>;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    sessionId: string;
+    viewer: LiveCallViewer | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceOpsActionCenter.d.ts

@@ -0,0 +1,13 @@
+import { type PropType } from "vue";
+import type { VoiceOpsActionDescriptor } from "../client/opsActionCenter";
+export declare const VoiceOpsActionCenter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    actions: PropType<VoiceOpsActionDescriptor[]>;
+    description: StringConstructor;
+    title: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    actions: PropType<VoiceOpsActionDescriptor[]>;
+    description: StringConstructor;
+    title: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/VoiceOpsStatus.d.ts

@@ -1,3 +1,5 @@
+import { type PropType } from "vue";
+import type { VoiceReactiveSource } from "../client/reactiveSource";
 export declare const VoiceOpsStatus: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     description: StringConstructor;
     includeLinks: {
@@ -9,6 +11,7 @@ export declare const VoiceOpsStatus: import("vue").DefineComponent<import("vue")
         default: string;
         type: StringConstructor;
     };
+    reactiveSource: PropType<VoiceReactiveSource>;
     title: StringConstructor;
 }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
@@ -23,6 +26,7 @@ export declare const VoiceOpsStatus: import("vue").DefineComponent<import("vue")
         default: string;
         type: StringConstructor;
     };
+    reactiveSource: PropType<VoiceReactiveSource>;
     title: StringConstructor;
 }>> & Readonly<{}>, {
     path: string;