@absolutejs/voice 0.0.22-beta.39 → 0.0.22-beta.390

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/evalRoutes.d.ts

@@ -0,0 +1,219 @@
+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;
+    startedAt?: number;
+    status: VoiceEvalStatus;
+    summary: ReturnType<typeof summarizeVoiceTrace>;
+};
+export type VoiceEvalTrendBucket = {
+    endedAt: number;
+    failed: number;
+    key: string;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    sessions: VoiceEvalSessionReport[];
+    status: VoiceEvalStatus;
+    total: number;
+    trend: VoiceEvalTrendBucket[];
+};
+export type VoiceEvalBaselineSummary = {
+    failed: number;
+    failedSessionIds: string[];
+    passRate: number;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalBaselineComparison = {
+    baseline: VoiceEvalBaselineSummary;
+    checkedAt: number;
+    current: VoiceEvalBaselineSummary;
+    deltas: {
+        failed: number;
+        passRate: number;
+        passed: number;
+        total: number;
+    };
+    newFailedSessionIds: string[];
+    recoveredSessionIds: string[];
+    reasons: string[];
+    status: VoiceEvalStatus;
+};
+export type VoiceEvalBaselineComparisonOptions = {
+    failOnNewFailedSessions?: boolean;
+    maxFailedDelta?: number;
+    maxPassRateDrop?: number;
+};
+export type VoiceEvalBaselineStore = {
+    get: () => Promise<VoiceEvalReport | undefined>;
+    set: (report: VoiceEvalReport) => Promise<void>;
+};
+export type VoiceScenarioEvalDefinition = {
+    description?: string;
+    forbiddenHandoffActions?: string[];
+    forbiddenLifecycleTypes?: string[];
+    id: string;
+    label?: string;
+    maxProviderErrors?: number;
+    maxSessionErrors?: number;
+    minSessions?: number;
+    minTurns?: number;
+    requiredAssistantIncludes?: string[];
+    requiredDisposition?: string;
+    requiredHandoffActions?: string[];
+    requiredLifecycleTypes?: string[];
+    requiredPayloadPaths?: string[];
+    requiredTranscriptIncludes?: string[];
+    requiredWorkflowContracts?: string[];
+    scenarioId?: string;
+};
+export type VoiceScenarioEvalSessionResult = {
+    eventCount: number;
+    issues: string[];
+    operationsRecordHref?: string;
+    sessionId: string;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalResult = {
+    description?: string;
+    failed: number;
+    id: string;
+    issues: string[];
+    label: string;
+    matchedSessions: number;
+    passed: number;
+    sessions: VoiceScenarioEvalSessionResult[];
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    scenarios: VoiceScenarioEvalResult[];
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceScenarioFixture = {
+    description?: string;
+    events: StoredVoiceTraceEvent[];
+    id: string;
+    label?: string;
+};
+export type VoiceScenarioFixtureStore = {
+    list: () => Promise<VoiceScenarioFixture[]>;
+};
+export type VoiceScenarioFixtureEvalResult = {
+    description?: string;
+    fixtureId: string;
+    label: string;
+    report: VoiceScenarioEvalReport;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioFixtureEvalReport = {
+    checkedAt: number;
+    failed: number;
+    fixtures: VoiceScenarioFixtureEvalResult[];
+    passed: number;
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceEvalLink = {
+    href: string;
+    label: string;
+};
+export type VoiceEvalRoutesOptions = {
+    baseline?: VoiceEvalReport | (() => Promise<VoiceEvalReport | undefined>);
+    baselineComparison?: VoiceEvalBaselineComparisonOptions;
+    baselineStore?: VoiceEvalBaselineStore;
+    events?: StoredVoiceTraceEvent[];
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    headers?: HeadersInit;
+    links?: VoiceEvalLink[];
+    limit?: number;
+    name?: string;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    path?: string;
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    title?: string;
+};
+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;
+export declare const createVoiceFileEvalBaselineStore: (filePath: string) => VoiceEvalBaselineStore;
+export declare const createVoiceFileScenarioFixtureStore: (filePath: string) => VoiceScenarioFixtureStore;
+export declare const renderVoiceEvalHTML: (report: VoiceEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceEvalBaselineHTML: (comparison: VoiceEvalBaselineComparison, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioEvalHTML: (report: VoiceScenarioEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioFixtureEvalHTML: (report: VoiceScenarioFixtureEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const createVoiceEvalRoutes: (options: VoiceEvalRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/fileStore.d.ts

@@ -1,4 +1,8 @@
+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';
@@ -7,9 +11,13 @@ 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 +28,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;
 };