@absolutejs/voice 0.0.22-beta.4 → 0.0.22-beta.400

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

@@ -0,0 +1,14 @@
+import { type VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../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

@@ -15,6 +15,7 @@ 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;
         sessionId: import("@angular/core").Signal<string | null>;

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

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { type VoiceDeliveryRuntimeViewModel } from '../client/deliveryRuntimeWidget';
+export declare class VoiceDeliveryRuntimeComponent implements OnDestroy, OnInit {
+    description?: string;
+    intervalMs?: number;
+    path: string;
+    title?: string;
+    private cleanup;
+    private store?;
+    model: import("@angular/core").WritableSignal<VoiceDeliveryRuntimeViewModel>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    deadLettered(): number;
+    tick(): void;
+    requeueDeadLetters(): void;
+    private options;
+}

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

@@ -0,0 +1,16 @@
+import { type VoiceDeliveryRuntimeClientOptions } from '../client/deliveryRuntime';
+import type { VoiceDeliveryRuntimeReport } from '../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-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.component.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { type VoiceOpsStatusViewModel } from '../client/opsStatusWidget';
+export declare class VoiceOpsStatusComponent implements OnDestroy, OnInit {
+    description?: string;
+    includeLinks: boolean;
+    intervalMs?: number;
+    path: string;
+    title?: string;
+    private cleanup;
+    private store?;
+    model: import("@angular/core").WritableSignal<VoiceOpsStatusViewModel>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private options;
+}

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

@@ -0,0 +1,12 @@
+import { type VoiceOpsStatusClientOptions } from '../client/opsStatus';
+import type { VoiceOpsStatusReport } from '../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 '../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 '../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 '../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 '../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 '../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

@@ -0,0 +1,12 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare class VoiceProviderStatusService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        providers: import("@angular/core").Signal<VoiceProviderHealthSummary<TProvider>[]>;
+        refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

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

@@ -0,0 +1,13 @@
+import { type VoiceReadinessFailuresClientOptions } from '../client/readinessFailures';
+import type { VoiceProductionReadinessReport } from '../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-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-snapshot.service.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceSessionSnapshotClientOptions } from '../client/sessionSnapshot';
+import type { VoiceSessionSnapshot } from '../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

@@ -8,13 +8,17 @@ export declare class VoiceStreamService {
             turnId?: string;
         }[]>;
         assistantTexts: import("@angular/core").Signal<string[]>;
+        call: import("@angular/core").Signal<import("..").VoiceCallLifecycleState | null>;
+        callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
         close: () => void;
         endTurn: () => void;
         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;
         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 '../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 '../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 '../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-workflow-status.service.d.ts

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

package/dist/assistantHealth.d.ts

@@ -0,0 +1,81 @@
+import { Elysia } from 'elysia';
+import { type VoiceAssistantRunsSummary } from './assistant';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceAssistantHealthFailure = {
+    at: number;
+    assistantId?: string;
+    error?: string;
+    provider?: string;
+    rateLimited?: boolean;
+    replayHref?: string;
+    sessionId: string;
+    status?: string;
+    turnId?: string;
+    type: StoredVoiceTraceEvent['type'];
+};
+export type VoiceAssistantHealthSummary<TProvider extends string = string> = {
+    assistantRuns: VoiceAssistantRunsSummary;
+    providerHealth: VoiceProviderHealthSummary<TProvider>[];
+    recentFailures: VoiceAssistantHealthFailure[];
+};
+export type VoiceAssistantHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    maxFailures?: number;
+    providers?: readonly TProvider[];
+    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, 'replayHref'>) => string);
+    store?: VoiceTraceEventStore;
+};
+export type VoiceAssistantHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceAssistantHealthSummaryOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceAssistantHealthSummary<TProvider>) => string | Promise<string>;
+};
+export type VoiceAssistantHealthRoutesOptions<TProvider extends string = string> = VoiceAssistantHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceAssistantHealth: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const renderVoiceAssistantHealthHTML: <TProvider extends string = string>(summary: VoiceAssistantHealthSummary<TProvider>) => string;
+export declare const createVoiceAssistantHealthJSONHandler: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => () => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const createVoiceAssistantHealthHTMLHandler: <TProvider extends string = string>(options: VoiceAssistantHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceAssistantHealthRoutes: <TProvider extends string = string>(options: VoiceAssistantHealthRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceAssistantHealthSummary<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/audit.d.ts

@@ -0,0 +1,128 @@
+export type VoiceAuditEventType = 'handoff' | 'operator.action' | 'profile.switch' | 'provider.call' | 'retention.policy' | 'tool.call';
+export type VoiceAuditActor = {
+    id: string;
+    kind: 'agent' | 'operator' | 'system' | 'worker';
+    name?: string;
+};
+export type VoiceAuditResource = {
+    id?: string;
+    type: string;
+};
+export type VoiceAuditOutcome = 'error' | 'skipped' | 'success';
+export type VoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
+    action: string;
+    actor?: VoiceAuditActor;
+    at?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: TPayload;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    traceId?: string;
+    type: VoiceAuditEventType;
+};
+export type StoredVoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = Omit<VoiceAuditEvent<TPayload>, 'at' | 'id'> & {
+    at: number;
+    id: string;
+};
+export type VoiceAuditEventFilter = {
+    actorId?: string;
+    after?: number;
+    afterOrAt?: number;
+    before?: number;
+    beforeOrAt?: number;
+    limit?: number;
+    outcome?: VoiceAuditOutcome | VoiceAuditOutcome[];
+    resourceId?: string;
+    resourceType?: string;
+    sessionId?: string;
+    traceId?: string;
+    type?: VoiceAuditEventType | VoiceAuditEventType[];
+};
+export type VoiceAuditEventStore<TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent> = {
+    append: (event: VoiceAuditEvent | TEvent) => Promise<TEvent> | TEvent;
+    get: (id: string) => Promise<TEvent | undefined> | TEvent | undefined;
+    list: (filter?: VoiceAuditEventFilter) => Promise<TEvent[]> | TEvent[];
+};
+export type VoiceAuditLogger = {
+    handoff: (input: Omit<VoiceHandoffAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    operatorAction: (input: Omit<VoiceOperatorAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    providerCall: (input: Omit<VoiceProviderAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    record: (event: VoiceAuditEvent) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    retention: (input: Omit<VoiceRetentionAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    toolCall: (input: Omit<VoiceToolAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+};
+export type VoiceProviderAuditEventInput = {
+    actor?: VoiceAuditActor;
+    cost?: Record<string, unknown>;
+    elapsedMs?: number;
+    error?: string;
+    kind: 'llm' | 'stt' | 'tts' | string;
+    metadata?: Record<string, unknown>;
+    model?: string;
+    outcome: VoiceAuditOutcome;
+    provider: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export type VoiceToolAuditEventInput = {
+    actor?: VoiceAuditActor;
+    elapsedMs?: number;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    toolCallId?: string;
+    toolName: string;
+    traceId?: string;
+};
+export type VoiceHandoffAuditEventInput = {
+    actor?: VoiceAuditActor;
+    fromAgentId?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    reason?: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    target?: string;
+    toAgentId?: string;
+    traceId?: string;
+};
+export type VoiceRetentionAuditEventInput = {
+    actor?: VoiceAuditActor;
+    dryRun: boolean;
+    metadata?: Record<string, unknown>;
+    report: {
+        deletedCount: number;
+        scopes: Array<{
+            deletedCount: number;
+            scope: string;
+            skippedReason?: string;
+        }>;
+    };
+    store: VoiceAuditEventStore;
+};
+export type VoiceOperatorAuditEventInput = {
+    action: string;
+    actor: VoiceAuditActor;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: Record<string, unknown>;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export declare const createVoiceAuditEvent: <TPayload extends Record<string, unknown> = Record<string, unknown>>(event: VoiceAuditEvent<TPayload>) => StoredVoiceAuditEvent<TPayload>;
+export declare const filterVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], filter?: VoiceAuditEventFilter) => TEvent[];
+export declare const createVoiceMemoryAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>() => VoiceAuditEventStore<TEvent>;
+export declare const recordVoiceAuditEvent: (store: VoiceAuditEventStore, event: VoiceAuditEvent) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceProviderAuditEvent: (input: VoiceProviderAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceToolAuditEvent: (input: VoiceToolAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceHandoffAuditEvent: (input: VoiceHandoffAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceRetentionAuditEvent: (input: VoiceRetentionAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceOperatorAuditEvent: (input: VoiceOperatorAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const createVoiceAuditLogger: (store: VoiceAuditEventStore) => VoiceAuditLogger;

package/dist/auditDeliveryRoutes.d.ts

@@ -0,0 +1,85 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditSinkDeliveryQueueStatus, type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore, type VoiceAuditSinkDeliveryWorkerResult } from './auditSinks';
+export type VoiceAuditDeliveryReport = {
+    checkedAt: number;
+    deliveries: VoiceAuditSinkDeliveryRecord[];
+    filter: VoiceAuditDeliveryFilter;
+    summary: VoiceAuditSinkDeliveryQueueSummary;
+};
+export type VoiceAuditDeliveryDrainWorker = {
+    drain: () => Promise<VoiceAuditSinkDeliveryWorkerResult> | VoiceAuditSinkDeliveryWorkerResult;
+};
+export type VoiceAuditDeliveryDrainReport = VoiceAuditSinkDeliveryWorkerResult & {
+    drainedAt: number;
+};
+export type VoiceAuditDeliveryFilter = {
+    limit?: number;
+    q?: string;
+    status?: VoiceAuditSinkDeliveryQueueStatus | 'all';
+};
+export type VoiceAuditDeliveryRoutesOptions = {
+    deadLetters?: VoiceAuditSinkDeliveryStore;
+    filter?: VoiceAuditDeliveryFilter;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    limit?: number;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceAuditDeliveryReport) => string | Promise<string>;
+    store: VoiceAuditSinkDeliveryStore;
+    title?: string;
+    worker?: VoiceAuditDeliveryDrainWorker;
+    workerPath?: false | string;
+};
+export declare const resolveVoiceAuditDeliveryFilter: (query?: Record<string, unknown>, base?: VoiceAuditDeliveryFilter) => VoiceAuditDeliveryFilter;
+export declare const buildVoiceAuditDeliveryReport: (options: VoiceAuditDeliveryRoutesOptions, filter?: VoiceAuditDeliveryFilter) => Promise<VoiceAuditDeliveryReport>;
+export declare const renderVoiceAuditDeliveryHTML: (report: VoiceAuditDeliveryReport, options?: {
+    title?: string;
+    workerPath?: false | string;
+}) => string;
+export declare const createVoiceAuditDeliveryJSONHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceAuditDeliveryReport>;
+export declare const createVoiceAuditDeliveryHTMLHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceAuditDeliveryRoutes: (options: VoiceAuditDeliveryRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceAuditDeliveryReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;