@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.511

package/dist/deliveryRuntime.d.ts

@@ -0,0 +1,158 @@
+import { Elysia } from "elysia";
+import { createVoiceAuditSinkDeliveryWorker, type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore, type VoiceAuditSinkDeliveryWorkerOptions, type VoiceAuditSinkDeliveryWorkerResult, type VoiceS3AuditSinkClient } from "./auditSinks";
+import { createVoiceTraceSinkDeliveryWorker, type VoiceRedisTaskLeaseCoordinator, type VoiceTraceSinkDeliveryQueueSummary, type VoiceTraceSinkDeliveryWorkerOptions, type VoiceTraceSinkDeliveryWorkerResult } from "./queue";
+import { type StoredVoiceTraceEvent, type VoiceS3TraceSinkClient, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore } from "./trace";
+import type { StoredVoiceAuditEvent } from "./audit";
+export type VoiceDeliveryRuntimeAuditConfig<TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = VoiceAuditSinkDeliveryWorkerOptions<TDelivery> & {
+    autoStart?: boolean;
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+};
+export type VoiceDeliveryRuntimeTraceConfig<TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = VoiceTraceSinkDeliveryWorkerOptions<TDelivery> & {
+    autoStart?: boolean;
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+};
+export type VoiceDeliveryRuntimeConfig<TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+    audit?: VoiceDeliveryRuntimeAuditConfig<TAuditDelivery>;
+    trace?: VoiceDeliveryRuntimeTraceConfig<TTraceDelivery>;
+};
+export type VoiceDeliveryRuntimeTickResult = {
+    audit?: VoiceAuditSinkDeliveryWorkerResult;
+    trace?: VoiceTraceSinkDeliveryWorkerResult;
+};
+export type VoiceDeliveryRuntimeRequeueDeadLettersResult = {
+    audit: number;
+    trace: number;
+    total: number;
+};
+export type VoiceDeliveryRuntimeSummary = {
+    audit?: VoiceAuditSinkDeliveryQueueSummary;
+    trace?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceDeliveryRuntime = {
+    audit?: ReturnType<typeof createVoiceAuditSinkDeliveryWorker>;
+    isRunning: () => boolean;
+    requeueDeadLetters: () => Promise<VoiceDeliveryRuntimeRequeueDeadLettersResult>;
+    start: () => void;
+    stop: () => void;
+    summarize: () => Promise<VoiceDeliveryRuntimeSummary>;
+    tick: () => Promise<VoiceDeliveryRuntimeTickResult>;
+    trace?: ReturnType<typeof createVoiceTraceSinkDeliveryWorker>;
+};
+export type VoiceDeliveryRuntimeReport = {
+    checkedAt: number;
+    isRunning: boolean;
+    summary: VoiceDeliveryRuntimeSummary;
+};
+export type VoiceDeliveryRuntimeRoutesOptions = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceDeliveryRuntimeReport, options: {
+        requeueDeadLettersPath?: false | string;
+        tickPath?: false | string;
+        title?: string;
+    }) => string | Promise<string>;
+    runtime: VoiceDeliveryRuntime;
+    requeueDeadLettersPath?: false | string;
+    tickPath?: false | string;
+    title?: string;
+};
+export type VoiceDeliveryRuntimePresetMode = "file" | "s3" | "webhook";
+export type VoiceDeliveryRuntimePresetLeaseConfig = VoiceRedisTaskLeaseCoordinator | {
+    audit: VoiceRedisTaskLeaseCoordinator;
+    trace: VoiceRedisTaskLeaseCoordinator;
+};
+export type VoiceDeliveryRuntimePresetBaseOptions = {
+    auditDeliveries: VoiceAuditSinkDeliveryStore;
+    auditSinkId?: string;
+    auditWorkerId?: string;
+    autoStart?: boolean;
+    failures?: {
+        maxFailures?: number;
+    };
+    leases: VoiceDeliveryRuntimePresetLeaseConfig;
+    pollIntervalMs?: number;
+    traceDeliveries: VoiceTraceSinkDeliveryStore;
+    traceSinkId?: string;
+    traceWorkerId?: string;
+};
+export type VoiceDeliveryRuntimeWebhookPresetOptions = VoiceDeliveryRuntimePresetBaseOptions & {
+    backoffMs?: number;
+    body?: {
+        audit?: (input: {
+            events: StoredVoiceAuditEvent[];
+        }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+        trace?: (input: {
+            events: StoredVoiceTraceEvent[];
+        }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    };
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    mode: "webhook";
+    retries?: number;
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceDeliveryRuntimeS3PresetOptions = VoiceDeliveryRuntimePresetBaseOptions & {
+    bucket?: string;
+    client?: VoiceS3AuditSinkClient & VoiceS3TraceSinkClient;
+    keyPrefix?: string;
+    mode: "s3";
+};
+export type VoiceDeliveryRuntimeFilePresetOptions = VoiceDeliveryRuntimePresetBaseOptions & {
+    directory: string;
+    mode: "file";
+};
+export type VoiceDeliveryRuntimePresetOptions = VoiceDeliveryRuntimeFilePresetOptions | VoiceDeliveryRuntimeS3PresetOptions | VoiceDeliveryRuntimeWebhookPresetOptions;
+export declare const createVoiceDeliveryRuntimePresetConfig: (options: VoiceDeliveryRuntimePresetOptions) => VoiceDeliveryRuntimeConfig;
+export declare const createVoiceDeliveryRuntime: <TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(config: VoiceDeliveryRuntimeConfig<TAuditDelivery, TTraceDelivery>) => VoiceDeliveryRuntime;
+export declare const buildVoiceDeliveryRuntimeReport: (runtime: VoiceDeliveryRuntime) => Promise<VoiceDeliveryRuntimeReport>;
+export declare const renderVoiceDeliveryRuntimeHTML: (report: VoiceDeliveryRuntimeReport, options?: {
+    requeueDeadLettersPath?: false | string;
+    tickPath?: false | string;
+    title?: string;
+}) => string;
+export declare const createVoiceDeliveryRuntimeRoutes: (options: VoiceDeliveryRuntimeRoutesOptions) => 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: VoiceDeliveryRuntimeReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/deliverySinkRoutes.d.ts

@@ -0,0 +1,117 @@
+import { Elysia } from "elysia";
+import { type VoiceAuditSinkDeliveryStore, type VoiceAuditSinkDeliveryQueueSummary } from "./auditSinks";
+import { type VoiceTraceSinkDeliveryQueueSummary } from "./queue";
+import type { VoiceTraceSinkDeliveryStore } from "./trace";
+export type VoiceDeliverySinkKind = "file" | "postgres" | "s3" | "sqlite" | "webhook" | (string & {});
+export type VoiceDeliverySinkDescriptor = {
+    description?: string;
+    href?: string;
+    id: string;
+    kind: VoiceDeliverySinkKind;
+    label: string;
+    mode?: string;
+    target?: string;
+};
+export type VoiceDeliverySinkDescriptorInput = {
+    description?: string;
+    href?: string;
+    id?: string;
+    kind: VoiceDeliverySinkKind;
+    label?: string;
+    mode?: string;
+    target?: string;
+};
+export type VoiceDeliverySinkPairOptions = {
+    auditHref?: string;
+    auditId?: string;
+    auditLabel?: string;
+    description?: string;
+    kind: VoiceDeliverySinkKind;
+    mode?: string;
+    target?: string;
+    traceHref?: string;
+    traceId?: string;
+    traceLabel?: string;
+};
+export type VoiceDeliverySinkReport = {
+    auditDeliveries?: VoiceTraceDeliverySinkSurface<VoiceAuditSinkDeliveryQueueSummary>;
+    checkedAt: number;
+    sinks: VoiceDeliverySinkDescriptor[];
+    status: "fail" | "pass" | "warn";
+    traceDeliveries?: VoiceTraceDeliverySinkSurface<VoiceTraceSinkDeliveryQueueSummary>;
+};
+export type VoiceTraceDeliverySinkSurface<TSummary> = {
+    href?: string;
+    label: string;
+    summary: TSummary;
+};
+export type VoiceDeliverySinkRoutesOptions = {
+    auditDeliveries?: {
+        href?: string;
+        label?: string;
+        store: VoiceAuditSinkDeliveryStore;
+    };
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceDeliverySinkReport) => string | Promise<string>;
+    sinks?: readonly VoiceDeliverySinkDescriptor[];
+    title?: string;
+    traceDeliveries?: {
+        href?: string;
+        label?: string;
+        store: VoiceTraceSinkDeliveryStore;
+    };
+};
+export declare const createVoiceDeliverySinkDescriptor: (input: VoiceDeliverySinkDescriptorInput) => VoiceDeliverySinkDescriptor;
+export declare const createVoiceFileDeliverySink: (input?: Omit<VoiceDeliverySinkDescriptorInput, "kind">) => VoiceDeliverySinkDescriptor;
+export declare const createVoiceWebhookDeliverySink: (input?: Omit<VoiceDeliverySinkDescriptorInput, "kind">) => VoiceDeliverySinkDescriptor;
+export declare const createVoiceS3DeliverySink: (input?: Omit<VoiceDeliverySinkDescriptorInput, "kind">) => VoiceDeliverySinkDescriptor;
+export declare const createVoicePostgresDeliverySink: (input?: Omit<VoiceDeliverySinkDescriptorInput, "kind">) => VoiceDeliverySinkDescriptor;
+export declare const createVoiceSQLiteDeliverySink: (input?: Omit<VoiceDeliverySinkDescriptorInput, "kind">) => VoiceDeliverySinkDescriptor;
+export declare const createVoiceDeliverySinkPair: (options: VoiceDeliverySinkPairOptions) => VoiceDeliverySinkDescriptor[];
+export declare const buildVoiceDeliverySinkReport: (options: VoiceDeliverySinkRoutesOptions) => Promise<VoiceDeliverySinkReport>;
+export declare const renderVoiceDeliverySinkHTML: (report: VoiceDeliverySinkReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceDeliverySinkRoutes: (options: VoiceDeliverySinkRoutesOptions) => 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: VoiceDeliverySinkReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/demoReadyRoutes.d.ts

@@ -0,0 +1,98 @@
+import { Elysia } from "elysia";
+import type { VoiceOpsStatusReport } from "./opsStatus";
+import type { VoicePhoneAgentProductionSmokeReport } from "./phoneAgentProductionSmoke";
+import type { VoicePhoneAgentSetupReport } from "./phoneAgent";
+import type { VoiceProductionReadinessReport } from "./productionReadiness";
+export type VoiceDemoReadyStatus = "fail" | "pass" | "warn";
+export type VoiceDemoReadySection = {
+    description?: string;
+    href?: string;
+    label: string;
+    status: VoiceDemoReadyStatus;
+    value?: number | string;
+};
+export type VoiceDemoReadyReport = {
+    checkedAt: number;
+    sections: VoiceDemoReadySection[];
+    status: VoiceDemoReadyStatus;
+    summary: {
+        opsStatus?: Pick<VoiceOpsStatusReport, "failed" | "passed" | "status" | "total">;
+        phoneSetup?: {
+            carriers: number;
+            ready: boolean;
+        };
+        phoneSmoke?: {
+            issues: number;
+            pass: boolean;
+            provider?: string;
+            sessionId?: string;
+        };
+        productionReadiness?: {
+            checks: number;
+            status: VoiceProductionReadinessReport["status"];
+        };
+    };
+    title: string;
+};
+type VoiceDemoReadyLoader<TValue> = TValue | ((input: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<TValue | undefined> | TValue | undefined);
+export type VoiceDemoReadyRoutesOptions = {
+    opsStatus?: false | {
+        href?: string;
+        load: VoiceDemoReadyLoader<VoiceOpsStatusReport>;
+    };
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    phoneSetup?: false | {
+        href?: string;
+        load: VoiceDemoReadyLoader<VoicePhoneAgentSetupReport>;
+    };
+    phoneSmoke?: false | {
+        href?: string;
+        load: VoiceDemoReadyLoader<VoicePhoneAgentProductionSmokeReport>;
+    };
+    productionReadiness?: false | {
+        href?: string;
+        load: VoiceDemoReadyLoader<VoiceProductionReadinessReport>;
+    };
+    render?: (report: VoiceDemoReadyReport) => Promise<string> | string;
+    title?: string;
+};
+export declare const buildVoiceDemoReadyReport: (options: VoiceDemoReadyRoutesOptions, input?: {
+    query?: Record<string, unknown>;
+    request?: Request;
+}) => Promise<VoiceDemoReadyReport>;
+export declare const renderVoiceDemoReadyHTML: (report: VoiceDemoReadyReport) => string;
+export declare const createVoiceDemoReadyRoutes: (options: VoiceDemoReadyRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/diagnosticsRoutes.d.ts

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
-import { evaluateVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventFilter, type VoiceTraceEventStore, type VoiceTraceRedactionConfig } from './trace';
+import { Elysia } from "elysia";
+import { evaluateVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventFilter, type VoiceTraceEventStore, type VoiceTraceRedactionConfig } from "./trace";
 export type VoiceDiagnosticsRoutesOptions = {
     evaluation?: Parameters<typeof evaluateVoiceTrace>[1];
     headers?: HeadersInit;

package/dist/dncRegistry.d.ts

@@ -0,0 +1,38 @@
+export type VoiceDNCSource = "internal" | "regulatory" | "imported";
+export type VoiceDNCEntry = {
+    phoneNumber: string;
+    source: VoiceDNCSource;
+    reason?: string;
+    addedAt: number;
+    expiresAt?: number;
+};
+export type VoiceDNCLookupVerdict = {
+    blocked: boolean;
+    entry: VoiceDNCEntry | null;
+    matchedFromExternal?: boolean;
+};
+export type VoiceDNCExternalLookup = (phoneNumber: string) => Promise<VoiceDNCEntry | null> | VoiceDNCEntry | null;
+export type CreateVoiceDNCRegistryOptions = {
+    entries?: VoiceDNCEntry[];
+    externalLookup?: VoiceDNCExternalLookup;
+    now?: () => number;
+};
+export declare const createVoiceDNCRegistry: (options?: CreateVoiceDNCRegistryOptions) => {
+    block: (phoneNumber: string, options?: {
+        source?: VoiceDNCSource;
+        reason?: string;
+        expiresAt?: number;
+    }) => VoiceDNCEntry;
+    check(phoneNumber: string): Promise<VoiceDNCLookupVerdict>;
+    checkSync(phoneNumber: string): VoiceDNCLookupVerdict;
+    has(phoneNumber: string): boolean;
+    snapshot(): VoiceDNCEntry[];
+    unblock: (phoneNumber: string) => boolean;
+};
+export type VoiceDNCRegistry = ReturnType<typeof createVoiceDNCRegistry>;
+export declare const importVoiceDNCFromCSV: (csv: string, options?: {
+    phoneColumn?: string;
+    reasonColumn?: string;
+    source?: VoiceDNCSource;
+    now?: () => number;
+}) => VoiceDNCEntry[];

package/dist/dtmfCollector.d.ts

@@ -0,0 +1,37 @@
+export type VoiceDTMFDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "*" | "#";
+export declare const VOICE_DTMF_DIGITS: readonly VoiceDTMFDigit[];
+export type VoiceDTMFCollectorState = {
+    status: "collecting";
+    digits: string;
+} | {
+    status: "completed";
+    digits: string;
+    reason: "length" | "terminator";
+} | {
+    status: "cancelled";
+    digits: string;
+} | {
+    status: "rejected";
+    digits: string;
+    reason: "invalid" | "timeout" | "too-short";
+};
+export type CreateVoiceDTMFCollectorOptions = {
+    prompt: string;
+    minLength?: number;
+    maxLength?: number;
+    terminator?: VoiceDTMFDigit | null;
+    timeoutMs?: number;
+    interDigitTimeoutMs?: number;
+    validator?: (digits: string) => boolean | string;
+    now?: () => number;
+};
+export declare const collectVoiceDTMFInput: (options: CreateVoiceDTMFCollectorOptions) => {
+    cancel(): VoiceDTMFCollectorState;
+    feed(digit: string, at?: number): VoiceDTMFCollectorState;
+    getState: () => VoiceDTMFCollectorState;
+    prompt: string;
+    subscribe(listener: (state: VoiceDTMFCollectorState) => void): () => void;
+    tick(at?: number): VoiceDTMFCollectorState;
+};
+export type VoiceDTMFCollector = ReturnType<typeof collectVoiceDTMFInput>;
+export declare const validateVoiceDTMFLuhn: (digits: string) => boolean;

package/dist/evalRoutes.d.ts

@@ -1,10 +1,11 @@
-import { Elysia } from 'elysia';
-import { type VoiceQualityReport, type VoiceQualityThresholds } from './qualityRoutes';
-import { summarizeVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventStore } from './trace';
-export type VoiceEvalStatus = 'pass' | 'fail';
+import { Elysia } from "elysia";
+import { type VoiceQualityReport, type VoiceQualityThresholds } from "./qualityRoutes";
+import { summarizeVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventStore } from "./trace";
+export type VoiceEvalStatus = "pass" | "fail";
 export type VoiceEvalSessionReport = {
     endedAt?: number;
     eventCount: number;
+    operationsRecordHref?: string;
     quality: VoiceQualityReport;
     scenarioId?: string;
     sessionId: string;
@@ -81,6 +82,7 @@ export type VoiceScenarioEvalDefinition = {
 export type VoiceScenarioEvalSessionResult = {
     eventCount: number;
     issues: string[];
+    operationsRecordHref?: string;
     sessionId: string;
     status: VoiceEvalStatus;
 };
@@ -142,6 +144,7 @@ export type VoiceEvalRoutesOptions = {
     links?: VoiceEvalLink[];
     limit?: number;
     name?: string;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
     path?: string;
     scenarios?: VoiceScenarioEvalDefinition[];
     store?: VoiceTraceEventStore;
@@ -151,17 +154,20 @@ export type VoiceEvalRoutesOptions = {
 export declare const runVoiceSessionEvals: (options?: {
     events?: StoredVoiceTraceEvent[];
     limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
     store?: VoiceTraceEventStore;
     thresholds?: VoiceQualityThresholds;
 }) => Promise<VoiceEvalReport>;
 export declare const runVoiceScenarioEvals: (options?: {
     events?: StoredVoiceTraceEvent[];
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
     scenarios?: VoiceScenarioEvalDefinition[];
     store?: VoiceTraceEventStore;
 }) => Promise<VoiceScenarioEvalReport>;
 export declare const runVoiceScenarioFixtureEvals: (options?: {
     fixtures?: VoiceScenarioFixture[];
     fixtureStore?: VoiceScenarioFixtureStore;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
     scenarios?: VoiceScenarioEvalDefinition[];
 }) => Promise<VoiceScenarioFixtureEvalReport>;
 export declare const compareVoiceEvalBaseline: (currentReport: VoiceEvalReport, baselineReport: VoiceEvalReport, options?: VoiceEvalBaselineComparisonOptions) => VoiceEvalBaselineComparison;

package/dist/fileStore.d.ts

@@ -1,15 +1,24 @@
-import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from './assistantMemory';
-import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
-import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { VoiceCampaignStore } from "./campaign";
+import { type VoiceAssistantMemoryRecord, type VoiceAssistantMemoryStore } from "./assistantMemory";
+import type { StoredVoiceIncidentBundleArtifact, VoiceIncidentBundleStore } from "./incidentBundle";
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from "./ops";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
+import type { VoiceRecordingStore } from "./recordingStore";
 export type VoiceFileStoreOptions = {
     directory: string;
     pretty?: boolean;
 };
-export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    incidentBundles: VoiceIncidentBundleStore<TIncident>;
     memories: VoiceAssistantMemoryStore<TMemory>;
     reviews: VoiceCallReviewStore<TReview>;
     session: VoiceSessionStore<TSession>;
@@ -20,12 +29,16 @@ export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceS
 export declare const createVoiceFileSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceFileStoreOptions) => VoiceSessionStore<TSession>;
 export declare const createVoiceFileReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceFileStoreOptions) => VoiceCallReviewStore<TArtifact>;
 export declare const createVoiceFileTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceFileStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoiceFileCampaignStore: (options: VoiceFileStoreOptions) => VoiceCampaignStore;
 export declare const createVoiceFileIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceIntegrationEventStore<TEvent>;
 export declare const createVoiceFileExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceFileStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
 export declare const createVoiceFileTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceFileStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceFileTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoiceFileAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceFileStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceFileAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceFileStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
 export declare const createVoiceFileAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceAssistantMemoryStore<TRecord>;
-export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TMemory>;
+export declare const createVoiceFileIncidentBundleStore: <TArtifact extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact>(options: VoiceFileStoreOptions) => VoiceIncidentBundleStore<TArtifact>;
+export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord, TIncident extends StoredVoiceIncidentBundleArtifact = StoredVoiceIncidentBundleArtifact, TMemory extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery, TIncident, TMemory>;
 export declare const createStoredVoiceCallReviewArtifact: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
     id: string;
 };
@@ -38,3 +51,4 @@ export declare const createStoredVoiceIntegrationEvent: <TEvent extends Omit<Voi
 export declare const createStoredVoiceExternalObjectMap: <TMapping extends Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt"> = Omit<VoiceExternalObjectMap, "id" | "createdAt" | "updatedAt">>(mapping: TMapping & {
     at?: number;
 }) => VoiceExternalObjectMap;
+export declare const createVoiceFileRecordingStore: (options: VoiceFileStoreOptions) => VoiceRecordingStore;