@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/angular/voice-agent-squad-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceAgentSquadStatusClientOptions, type VoiceAgentSquadStatusReport } from "../client/agentSquadStatus";
+export declare class VoiceAgentSquadStatusService {
+    connect(path?: string, options?: VoiceAgentSquadStatusClientOptions): {
+        close: () => void;
+        current: import("@angular/core").Signal<import("../client").VoiceAgentSquadSpecialist | undefined>;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+        report: import("@angular/core").Signal<VoiceAgentSquadStatusReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

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

@@ -0,0 +1,12 @@
+import { type VoiceCallDebuggerClientOptions } from "../client/callDebugger";
+import type { VoiceCallDebuggerReport } from "../core/callDebugger";
+export declare class VoiceCallDebuggerService {
+    connect(path: string, options?: VoiceCallDebuggerClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceCallDebuggerReport | undefined>;
+        report: import("@angular/core").Signal<VoiceCallDebuggerReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

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/angular/voice-campaign-dialer-proof.service.d.ts

@@ -0,0 +1,14 @@
+import { type VoiceCampaignDialerProofClientOptions } from "../client/campaignDialerProof";
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from "../core/campaignDialers";
+export declare class VoiceCampaignDialerProofService {
+    connect(path?: string, options?: VoiceCampaignDialerProofClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+        report: import("@angular/core").Signal<VoiceCampaignDialerProofReport | undefined>;
+        runProof: () => Promise<VoiceCampaignDialerProofReport>;
+        status: import("@angular/core").Signal<VoiceCampaignDialerProofStatus | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-controller.service.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceControllerOptions, VoiceTurnRecord } from '../types';
+import type { VoiceControllerOptions, VoiceTurnRecord } from "../core/types";
 export declare class VoiceControllerService {
     connect<TResult = unknown>(path: string, options?: VoiceControllerOptions): {
         assistantAudio: import("@angular/core").Signal<{
@@ -15,8 +15,10 @@ export declare class VoiceControllerService {
         isConnected: import("@angular/core").Signal<boolean>;
         isRecording: import("@angular/core").Signal<boolean>;
         partial: import("@angular/core").Signal<string>;
+        reconnect: import("@angular/core").Signal<import("..").VoiceReconnectClientState>;
         recordingError: import("@angular/core").Signal<string | null>;
         sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+        simulateDisconnect: () => void;
         sessionId: import("@angular/core").Signal<string | null>;
         startRecording: () => Promise<void>;
         status: import("@angular/core").Signal<import("..").VoiceSessionStatus | "idle">;

package/dist/angular/voice-cost-dashboard.service.d.ts

@@ -0,0 +1,15 @@
+import type { StoredVoiceTraceEvent } from "../core/trace";
+import { type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "../client/costDashboard";
+export type VoiceCostDashboardServiceOptions = VoiceCostDashboardOptions & {
+    currency?: string;
+    title?: string;
+};
+export declare class VoiceCostDashboardService {
+    build(options: VoiceCostDashboardServiceOptions): {
+        currency: string;
+        report: import("@angular/core").Signal<VoiceCostDashboardReport>;
+        title: string;
+        setEvents: (next: ReadonlyArray<StoredVoiceTraceEvent>) => void;
+        setFilters: (next: Partial<typeof options>) => void;
+    };
+}

package/dist/angular/voice-delivery-runtime.service.d.ts

@@ -0,0 +1,16 @@
+import { type VoiceDeliveryRuntimeClientOptions } from "../client/deliveryRuntime";
+import type { VoiceDeliveryRuntimeReport } from "../core/deliveryRuntime";
+export declare class VoiceDeliveryRuntimeService {
+    connect(path?: string, options?: VoiceDeliveryRuntimeClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        actionError: import("@angular/core").Signal<string | null>;
+        actionStatus: import("@angular/core").Signal<"completed" | "failed" | "idle" | "running">;
+        isLoading: import("@angular/core").Signal<boolean>;
+        requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+        refresh: () => Promise<VoiceDeliveryRuntimeReport | undefined>;
+        report: import("@angular/core").Signal<VoiceDeliveryRuntimeReport | undefined>;
+        tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-live-agent-console.service.d.ts

@@ -0,0 +1,16 @@
+import { type CreateLiveAgentConsoleOptions, type LiveAgentConsole, type LiveAgentConsoleState } from "../client/liveAgentConsole";
+export type VoiceLiveAgentConsoleServiceOptions = CreateLiveAgentConsoleOptions & {
+    takeoverButtonLabel?: string;
+    title?: string;
+};
+export declare class VoiceLiveAgentConsoleService {
+    build(options: VoiceLiveAgentConsoleServiceOptions): {
+        releaseTakeover: () => void;
+        setCaller: (caller: Parameters<LiveAgentConsole["setCaller"]>[0]) => void;
+        state: import("@angular/core").Signal<LiveAgentConsoleState>;
+        stop: () => void;
+        takeover: (reason?: string) => void;
+        takeoverButtonLabel: string;
+        title: string;
+    };
+}

package/dist/angular/voice-live-call-viewer.service.d.ts

@@ -0,0 +1,16 @@
+import { type CreateLiveCallViewerOptions, type LiveCallViewState, type LiveCallViewer } from "../client/liveCallViewer";
+export type VoiceLiveCallViewerServiceOptions = CreateLiveCallViewerOptions & {
+    title?: string;
+    viewer?: LiveCallViewer;
+};
+export declare class VoiceLiveCallViewerService {
+    build(options: VoiceLiveCallViewerServiceOptions): {
+        noteAgentAudio: (at?: number) => void;
+        notePartial: (text: string, at?: number) => void;
+        noteTranscript: (text: string, at?: number) => void;
+        reset: (sessionId: string, startedAt?: number) => void;
+        state: import("@angular/core").Signal<LiveCallViewState>;
+        stop: () => void;
+        title: string;
+    };
+}

package/dist/angular/voice-live-ops.service.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceLiveOpsActionResult, type VoiceLiveOpsClientOptions } from "../client/liveOps";
+export declare class VoiceLiveOpsService {
+    connect(options?: VoiceLiveOpsClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isRunning: import("@angular/core").Signal<boolean>;
+        lastResult: import("@angular/core").Signal<VoiceLiveOpsActionResult | undefined>;
+        run: (input: import("..").VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
+        runningAction: import("@angular/core").Signal<"escalate" | "operator-takeover" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
+    };
+}

package/dist/angular/voice-ops-action-center.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceOpsActionCenterClientOptions, type VoiceOpsActionDescriptor, type VoiceOpsActionRunResult } from "../client/opsActionCenter";
+export declare class VoiceOpsActionCenterService {
+    connect(options?: VoiceOpsActionCenterClientOptions): {
+        actions: import("@angular/core").Signal<VoiceOpsActionDescriptor[]>;
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isRunning: import("@angular/core").Signal<boolean>;
+        lastResult: import("@angular/core").Signal<VoiceOpsActionRunResult | undefined>;
+        run: (actionId: string) => Promise<VoiceOpsActionRunResult | undefined>;
+        runningActionId: import("@angular/core").Signal<string | undefined>;
+        setActions: (actions: VoiceOpsActionDescriptor[]) => void;
+    };
+}

package/dist/angular/voice-ops-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceOpsStatusClientOptions } from "../client/opsStatus";
+import type { VoiceOpsStatusReport } from "../core/opsStatus";
+export declare class VoiceOpsStatusService {
+    connect(path?: string, options?: VoiceOpsStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+        report: import("@angular/core").Signal<VoiceOpsStatusReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-platform-coverage.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoicePlatformCoverageClientOptions } from "../client/platformCoverage";
+import type { VoicePlatformCoverageSummary } from "../core/platformCoverage";
+export declare class VoicePlatformCoverageService {
+    connect(path?: string, options?: VoicePlatformCoverageClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoicePlatformCoverageSummary | undefined>;
+        report: import("@angular/core").Signal<VoicePlatformCoverageSummary | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-profile-comparison.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProfileComparisonClientOptions } from "../client/profileComparison";
+import type { VoiceRealCallProfileHistoryReport } from "../core/proofTrends";
+export declare class VoiceProfileComparisonService {
+    connect(path?: string, options?: VoiceProfileComparisonClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceRealCallProfileHistoryReport | undefined>;
+        report: import("@angular/core").Signal<VoiceRealCallProfileHistoryReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-proof-trends.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProofTrendsClientOptions } from "../client/proofTrends";
+import type { VoiceProofTrendReport } from "../core/proofTrends";
+export declare class VoiceProofTrendsService {
+    connect(path?: string, options?: VoiceProofTrendsClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProofTrendReport | undefined>;
+        report: import("@angular/core").Signal<VoiceProofTrendReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-provider-capabilities.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderCapabilitiesClientOptions } from "../client/providerCapabilities";
+import type { VoiceProviderCapabilityReport } from "../core/providerCapabilities";
+export declare class VoiceProviderCapabilitiesService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        report: import("@angular/core").Signal<VoiceProviderCapabilityReport<TProvider> | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-provider-contracts.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderContractsClientOptions } from "../client/providerContracts";
+import type { VoiceProviderContractMatrixReport } from "../core/providerStackRecommendations";
+export declare class VoiceProviderContractsService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProviderContractMatrixReport<TProvider> | undefined>;
+        report: import("@angular/core").Signal<VoiceProviderContractMatrixReport<TProvider> | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-provider-status.service.d.ts

@@ -1,5 +1,5 @@
-import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
-import type { VoiceProviderHealthSummary } from '../providerHealth';
+import { type VoiceProviderStatusClientOptions } from "../client/providerStatus";
+import type { VoiceProviderHealthSummary } from "../core/providerHealth";
 export declare class VoiceProviderStatusService {
     connect<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
         close: () => void;

package/dist/angular/voice-readiness-failures.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceReadinessFailuresClientOptions } from "../client/readinessFailures";
+import type { VoiceProductionReadinessReport } from "../core/productionReadiness";
+export declare class VoiceReadinessFailuresService {
+    connect(path?: string, options?: VoiceReadinessFailuresClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        explanations: import("@angular/core").Signal<import("..").VoiceProductionReadinessCheck[]>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceProductionReadinessReport | undefined>;
+        report: import("@angular/core").Signal<VoiceProductionReadinessReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-reconnect-profile-evidence.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceReconnectProfileEvidenceClientOptions } from "../client/reconnectProfileEvidence";
+import type { VoiceReconnectProfileEvidenceSummary } from "../core/proofTrends";
+export declare class VoiceReconnectProfileEvidenceService {
+    connect(path?: string, options?: VoiceReconnectProfileEvidenceClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceReconnectProfileEvidenceSummary | undefined>;
+        report: import("@angular/core").Signal<VoiceReconnectProfileEvidenceSummary | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-replay-timeline.service.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type ReplayTimelineReport } from "../client/replayTimeline";
+export type VoiceReplayTimelineServiceOptions = {
+    artifact: VoiceCallReviewArtifact;
+    title?: string;
+};
+export declare class VoiceReplayTimelineService {
+    build(options: VoiceReplayTimelineServiceOptions): {
+        report: import("@angular/core").Signal<ReplayTimelineReport>;
+        title: string | undefined;
+        setArtifact: (next: VoiceCallReviewArtifact) => void;
+    };
+}

package/dist/angular/voice-routing-status.service.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceRoutingStatusClientOptions } from "../client/routingStatus";
+export declare class VoiceRoutingStatusService {
+    connect(path?: string, options?: VoiceRoutingStatusClientOptions): {
+        close: () => void;
+        decision: import("@angular/core").Signal<import("..").VoiceRoutingEvent | null>;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-session-observability.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceSessionObservabilityClientOptions } from "../client/sessionObservability";
+import type { VoiceSessionObservabilityReport } from "../core/sessionObservability";
+export declare class VoiceSessionObservabilityService {
+    connect(path?: string, options?: VoiceSessionObservabilityClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceSessionObservabilityReport | null>;
+        report: import("@angular/core").Signal<VoiceSessionObservabilityReport | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-session-snapshot.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceSessionSnapshotClientOptions } from "../client/sessionSnapshot";
+import type { VoiceSessionSnapshot } from "../core/sessionSnapshot";
+export declare class VoiceSessionSnapshotService {
+    connect(path: string, options?: VoiceSessionSnapshotClientOptions): {
+        close: () => void;
+        download: () => Blob;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceSessionSnapshot | undefined>;
+        snapshot: import("@angular/core").Signal<VoiceSessionSnapshot | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-stream.service.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceConnectionOptions, VoiceTurnRecord } from '../types';
+import type { VoiceConnectionOptions, VoiceTurnRecord } from "../core/types";
 export declare class VoiceStreamService {
     connect<TResult = unknown>(path: string, options?: VoiceConnectionOptions): {
         assistantAudio: import("@angular/core").Signal<{
@@ -15,8 +15,11 @@ export declare class VoiceStreamService {
         error: import("@angular/core").Signal<string | null>;
         isConnected: import("@angular/core").Signal<boolean>;
         partial: import("@angular/core").Signal<string>;
+        reconnect: import("@angular/core").Signal<import("..").VoiceReconnectClientState>;
         sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+        simulateDisconnect: () => void;
         sessionId: import("@angular/core").Signal<string | null>;
+        sessionMetadata: import("@angular/core").Signal<Record<string, unknown> | null>;
         status: import("@angular/core").Signal<import("..").VoiceSessionStatus | "idle">;
         turns: import("@angular/core").Signal<VoiceTurnRecord<TResult>[]>;
     };

package/dist/angular/voice-trace-timeline.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTraceTimelineClientOptions } from "../client/traceTimeline";
+import type { VoiceTraceTimelineReport } from "../core/traceTimeline";
+export declare class VoiceTraceTimelineService {
+    connect(path?: string, options?: VoiceTraceTimelineClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTraceTimelineReport | null>;
+        report: import("@angular/core").Signal<VoiceTraceTimelineReport | null>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-latency.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceTurnLatencyClientOptions } from "../client/turnLatency";
+import type { VoiceTurnLatencyReport } from "../core/turnLatency";
+export declare class VoiceTurnLatencyService {
+    connect(path?: string, options?: VoiceTurnLatencyClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnLatencyReport | undefined>;
+        runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-turn-quality.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceTurnQualityClientOptions } from "../client/turnQuality";
+import type { VoiceTurnQualityReport } from "../core/turnQuality";
+export declare class VoiceTurnQualityService {
+    connect(path?: string, options?: VoiceTurnQualityClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+        report: import("@angular/core").Signal<VoiceTurnQualityReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/angular/voice-widget.service.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceControllerOptions } from "../core/types";
+import { type VoiceWidgetLabels, type VoiceWidgetTheme, type VoiceWidgetViewModel } from "../client/voiceWidgetView";
+export type CreateVoiceWidgetServiceOptions = VoiceControllerOptions & {
+    labels?: VoiceWidgetLabels;
+    theme?: VoiceWidgetTheme;
+    title?: string;
+};
+export declare class VoiceWidgetService {
+    connect<TResult = unknown>(path: string, options?: CreateVoiceWidgetServiceOptions): {
+        close: () => void;
+        endCall: () => void;
+        getHTML: () => string;
+        mute: () => void;
+        startCall: () => Promise<void>;
+        unmute: () => Promise<void>;
+        viewModel: import("@angular/core").Signal<VoiceWidgetViewModel>;
+    };
+}

package/dist/angular/voice-workflow-status.service.d.ts

@@ -1,5 +1,5 @@
-import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
-import type { VoiceScenarioEvalReport } from '../evalRoutes';
+import { type VoiceWorkflowStatusClientOptions } from "../client/workflowStatus";
+import type { VoiceScenarioEvalReport } from "../core/evalRoutes";
 export declare class VoiceWorkflowStatusService {
     connect(path?: string, options?: VoiceWorkflowStatusClientOptions): {
         close: () => void;

package/dist/client/actions.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceServerMessage } from '../types';
+import type { VoiceServerMessage } from "../core/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;