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

package/dist/vue/useVoiceAgentSquadStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceAgentSquadSpecialist, type VoiceAgentSquadStatusClientOptions, type VoiceAgentSquadStatusReport } from "../client/agentSquadStatus";
+export declare function useVoiceAgentSquadStatus(path?: string, options?: VoiceAgentSquadStatusClientOptions): {
+    current: import("vue").ShallowRef<VoiceAgentSquadSpecialist | undefined, VoiceAgentSquadSpecialist | undefined>;
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    report: import("vue").ShallowRef<VoiceAgentSquadStatusReport | undefined, VoiceAgentSquadStatusReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceCallDebugger.d.ts

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

package/dist/vue/useVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceCampaignDialerProofClientOptions } from "../client/campaignDialerProof";
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from "../core/campaignDialers";
+export declare function useVoiceCampaignDialerProof(path?: string, options?: VoiceCampaignDialerProofClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    report: import("vue").ShallowRef<VoiceCampaignDialerProofReport | undefined, VoiceCampaignDialerProofReport | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    status: import("vue").ShallowRef<VoiceCampaignDialerProofStatus | undefined, VoiceCampaignDialerProofStatus | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceController.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceControllerOptions, VoiceTurnRecord } from '../types';
-export declare const useVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => {
+import type { VoiceControllerOptions, VoiceTurnRecord } from "../core/types";
+export declare function useVoiceController<TResult = unknown>(path: string, options?: VoiceControllerOptions): {
     assistantAudio: import("vue").ShallowRef<{
         chunk: Uint8Array;
         format: import("..").AudioFormat;
@@ -13,18 +13,20 @@ export declare const useVoiceController: <TResult = unknown>(path: string, optio
     }[]>;
     assistantTexts: import("vue").ShallowRef<string[], string[]>;
     bindHTMX: (options: import("..").VoiceHTMXBindingOptions) => () => void;
-    close: () => void;
-    endTurn: () => void;
     error: import("vue").Ref<string | null, string | null>;
     isConnected: import("vue").Ref<boolean, boolean>;
     isRecording: import("vue").Ref<boolean, boolean>;
     partial: import("vue").Ref<string, string>;
+    reconnect: import("vue").ShallowRef<import("..").VoiceReconnectClientState, import("..").VoiceReconnectClientState>;
     recordingError: import("vue").Ref<string | null, string | null>;
-    sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     sessionId: import("vue").Ref<string | null, string | null>;
-    startRecording: () => Promise<void>;
     status: import("vue").Ref<import("..").VoiceSessionStatus | "idle", import("..").VoiceSessionStatus | "idle">;
+    turns: import("vue").ShallowRef<VoiceTurnRecord<TResult>[], VoiceTurnRecord<TResult>[]>;
+    close: () => void;
+    endTurn: () => void;
+    sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
+    startRecording: () => Promise<void>;
     stopRecording: () => void;
     toggleRecording: () => Promise<void>;
-    turns: import("vue").ShallowRef<VoiceTurnRecord<TResult>[], VoiceTurnRecord<TResult>[]>;
 };

package/dist/vue/useVoiceDeliveryRuntime.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceDeliveryRuntimeClientOptions } from "../client/deliveryRuntime";
+import type { VoiceDeliveryRuntimeReport } from "../core/deliveryRuntime";
+export declare function useVoiceDeliveryRuntime(path?: string, options?: VoiceDeliveryRuntimeClientOptions): {
+    actionError: import("vue").Ref<string | null, string | null>;
+    actionStatus: import("vue").Ref<"completed" | "failed" | "idle" | "running", "completed" | "failed" | "idle" | "running">;
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceDeliveryRuntimeReport | undefined>;
+    report: import("vue").ShallowRef<VoiceDeliveryRuntimeReport | undefined, VoiceDeliveryRuntimeReport | undefined>;
+    requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceLiveOps.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceLiveOpsClientOptions, type VoiceLiveOpsActionResult } from "../client/liveOps";
+export declare function useVoiceLiveOps(options?: VoiceLiveOpsClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    lastResult: import("vue").ShallowRef<VoiceLiveOpsActionResult | undefined, VoiceLiveOpsActionResult | undefined>;
+    run: (input: import("..").VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
+    runningAction: import("vue").Ref<"escalate" | "operator-takeover" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "pause-assistant" | "resume-assistant" | "tag" | undefined, "escalate" | "operator-takeover" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceOpsActionCenter.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceOpsActionCenterClientOptions, type VoiceOpsActionDescriptor, type VoiceOpsActionRunResult } from "../client/opsActionCenter";
+export declare function useVoiceOpsActionCenter(options?: VoiceOpsActionCenterClientOptions): {
+    actions: import("vue").ShallowRef<VoiceOpsActionDescriptor[], VoiceOpsActionDescriptor[]>;
+    error: import("vue").Ref<string | null, string | null>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    lastResult: import("vue").ShallowRef<VoiceOpsActionRunResult | undefined, VoiceOpsActionRunResult | undefined>;
+    run: (actionId: string) => Promise<VoiceOpsActionRunResult | undefined>;
+    runningActionId: import("vue").Ref<string | undefined, string | undefined>;
+    setActions: (actions: VoiceOpsActionDescriptor[]) => void;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceOpsStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceOpsStatusClientOptions } from "../client/opsStatus";
+import type { VoiceOpsStatusReport } from "../core/opsStatus";
+export declare function useVoiceOpsStatus(path?: string, options?: VoiceOpsStatusClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+    report: import("vue").ShallowRef<VoiceOpsStatusReport | undefined, VoiceOpsStatusReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoicePlatformCoverage.d.ts

@@ -0,0 +1,9 @@
+import { type VoicePlatformCoverageClientOptions } from "../client/platformCoverage";
+import type { VoicePlatformCoverageSummary } from "../core/platformCoverage";
+export declare function useVoicePlatformCoverage(path?: string, options?: VoicePlatformCoverageClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoicePlatformCoverageSummary | undefined>;
+    report: import("vue").ShallowRef<VoicePlatformCoverageSummary | undefined, VoicePlatformCoverageSummary | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProfileComparison.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProfileComparisonClientOptions } from "../client/profileComparison";
+import type { VoiceRealCallProfileHistoryReport } from "../core/proofTrends";
+export declare function useVoiceProfileComparison(path?: string, options?: VoiceProfileComparisonClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceRealCallProfileHistoryReport | undefined>;
+    report: import("vue").ShallowRef<VoiceRealCallProfileHistoryReport | undefined, VoiceRealCallProfileHistoryReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProofTrends.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProofTrendsClientOptions } from "../client/proofTrends";
+import type { VoiceProofTrendReport } from "../core/proofTrends";
+export declare function useVoiceProofTrends(path?: string, options?: VoiceProofTrendsClientOptions): {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceProofTrendReport | undefined>;
+    report: import("vue").ShallowRef<VoiceProofTrendReport | undefined, VoiceProofTrendReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderCapabilities.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProviderCapabilitiesClientOptions } from "../client/providerCapabilities";
+import type { VoiceProviderCapabilityReport } from "../core/providerCapabilities";
+export declare function useVoiceProviderCapabilities<TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+    report: import("vue").ShallowRef<VoiceProviderCapabilityReport<TProvider> | undefined, VoiceProviderCapabilityReport<TProvider> | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderContracts.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProviderContractsClientOptions } from "../client/providerContracts";
+import type { VoiceProviderContractMatrixReport } from "../core/providerStackRecommendations";
+export declare function useVoiceProviderContracts<TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions): {
+    error: import("vue").ShallowRef<string | null, string | null>;
+    isLoading: import("vue").ShallowRef<boolean, boolean>;
+    refresh: () => Promise<VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    report: import("vue").ShallowRef<VoiceProviderContractMatrixReport<TProvider> | undefined, VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    updatedAt: import("vue").ShallowRef<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderSimulationControls.d.ts

@@ -0,0 +1,24 @@
+import { type VoiceProviderSimulationControlsOptions } from "../client/providerSimulationControls";
+export declare function useVoiceProviderSimulationControls<TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>): {
+    error: import("vue").Ref<string | null, string | null>;
+    isRunning: import("vue").Ref<boolean, boolean>;
+    lastResult: import("vue").Ref<{
+        fallbackProvider?: import("vue").UnwrapRef<TProvider> | undefined;
+        mode: import("../testing").VoiceIOProviderFailureSimulationMode;
+        provider: import("vue").UnwrapRef<TProvider>;
+        sessionId: string;
+        status: "simulated";
+        suppressedUntil?: number | undefined;
+    } | null, import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | {
+        fallbackProvider?: import("vue").UnwrapRef<TProvider> | undefined;
+        mode: import("../testing").VoiceIOProviderFailureSimulationMode;
+        provider: import("vue").UnwrapRef<TProvider>;
+        sessionId: string;
+        status: "simulated";
+        suppressedUntil?: number | undefined;
+    } | null>;
+    mode: import("vue").Ref<import("../testing").VoiceIOProviderFailureSimulationMode | null, import("../testing").VoiceIOProviderFailureSimulationMode | null>;
+    provider: [TProvider | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & TProvider, import("vue").Ref<import("vue").Ref<any, any> & TProvider, import("vue").Ref<any, any> & TProvider>, import("vue").Ref<any, any> & TProvider> : import("vue").Ref<import("vue").UnwrapRef<TProvider> | null, TProvider | import("vue").UnwrapRef<TProvider> | null>;
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/vue/useVoiceProviderStatus.d.ts

@@ -1,6 +1,6 @@
-import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
-import type { VoiceProviderHealthSummary } from '../providerHealth';
-export declare const useVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+import { type VoiceProviderStatusClientOptions } from "../client/providerStatus";
+import type { VoiceProviderHealthSummary } from "../core/providerHealth";
+export declare function useVoiceProviderStatus<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
     error: import("vue").Ref<string | null, string | null>;
     isLoading: import("vue").Ref<boolean, boolean>;
     providers: import("vue").ShallowRef<VoiceProviderHealthSummary<TProvider>[], VoiceProviderHealthSummary<TProvider>[]>;