@absolutejs/voice 0.0.22-beta.43 → 0.0.22-beta.430

package/dist/dataControl.d.ts

@@ -0,0 +1,180 @@
+import type { VoiceCampaignStore } from './campaign';
+import { Elysia } from 'elysia';
+import { type VoiceAuditActor, type VoiceAuditEventFilter, type VoiceAuditEventStore } from './audit';
+import { exportVoiceAuditTrail } from './auditExport';
+import type { VoiceAuditSinkDeliveryStore } from './auditSinks';
+import type { VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
+import type { VoiceIncidentBundleStore } from './incidentBundle';
+import type { VoiceCallReviewStore } from './testing/review';
+import type { VoiceTraceEventStore, VoiceTracePruneFilter, VoiceTraceSinkDeliveryStore } from './trace';
+import type { VoiceSessionStore } from './types';
+export declare const voiceComplianceRedactionDefaults: {
+    keys: string[];
+    redactEmails: true;
+    redactPhoneNumbers: true;
+};
+export type VoiceDataRetentionScope = 'auditDeliveries' | 'campaigns' | 'events' | 'incidentBundles' | 'reviews' | 'sessions' | 'tasks' | 'traceDeliveries' | 'traces';
+export type VoiceDataRetentionStores = {
+    campaigns?: VoiceCampaignStore;
+    events?: VoiceIntegrationEventStore;
+    incidentBundles?: VoiceIncidentBundleStore;
+    reviews?: VoiceCallReviewStore;
+    session?: VoiceSessionStore;
+    sessions?: VoiceSessionStore;
+    tasks?: VoiceOpsTaskStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceDataRetentionPolicy = VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    auditActor?: VoiceAuditActor;
+    before?: number;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    keepNewest?: Partial<Record<VoiceDataRetentionScope, number>>;
+    limit?: number;
+    scopes?: VoiceDataRetentionScope[];
+    traceFilter?: VoiceTracePruneFilter;
+};
+export type VoiceDataRetentionScopeReport = {
+    deletedIds: string[];
+    deletedCount: number;
+    dryRun: boolean;
+    keepNewest?: number;
+    scannedCount: number;
+    scope: VoiceDataRetentionScope;
+    skippedReason?: 'missing-store' | 'missing-selector';
+};
+export type VoiceDataRetentionReport = {
+    checkedAt: number;
+    deletedCount: number;
+    dryRun: boolean;
+    scopes: VoiceDataRetentionScopeReport[];
+};
+export type VoiceDataControlStorageSurface = {
+    configured: boolean;
+    control: 'audit' | 'artifact' | 'queue' | 'session' | 'workflow';
+    name: string;
+    selfHosted: boolean;
+};
+export type VoiceDataControlProviderKeySurface = {
+    env?: string;
+    name: string;
+    recommendation: string;
+    required: boolean;
+};
+export type VoiceDataControlReport = {
+    auditExport?: Awaited<ReturnType<typeof exportVoiceAuditTrail>>;
+    checkedAt: number;
+    deletionProof?: VoiceDataRetentionReport;
+    redaction: {
+        defaults: typeof voiceComplianceRedactionDefaults;
+        enabled: boolean;
+    };
+    retentionPlan: VoiceDataRetentionReport;
+    storage: VoiceDataControlStorageSurface[];
+    providerKeys: VoiceDataControlProviderKeySurface[];
+    zeroRetentionAvailable: boolean;
+};
+export type VoiceDataControlAssertionInput = {
+    maxDeletionDeleted?: number;
+    maxMissingConfiguredStorage?: number;
+    maxMissingSelfHostedStorage?: number;
+    maxRetentionDeleted?: number;
+    minAuditExportEvents?: number;
+    minConfiguredStorage?: number;
+    minProviderKeys?: number;
+    requiredControls?: VoiceDataControlStorageSurface['control'][];
+    requiredDeletionScopes?: VoiceDataRetentionScope[];
+    requiredProviderKeys?: string[];
+    requiredRetentionScopes?: VoiceDataRetentionScope[];
+    requiredStorage?: string[];
+    requireAuditExport?: boolean;
+    requireDeletionDryRun?: boolean;
+    requireDeletionProof?: boolean;
+    requireRedaction?: boolean;
+    requireRetentionDryRun?: boolean;
+    requireSelfHostedStorage?: boolean;
+    requireZeroRetentionAvailable?: boolean;
+};
+export type VoiceDataControlAssertionReport = {
+    auditExportEvents: number;
+    configuredStorage: string[];
+    controls: VoiceDataControlStorageSurface['control'][];
+    deletionDeleted: number;
+    deletionDryRun?: boolean;
+    deletionScopes: VoiceDataRetentionScope[];
+    issues: string[];
+    ok: boolean;
+    providerKeys: string[];
+    redactionEnabled: boolean;
+    retentionDeleted: number;
+    retentionDryRun: boolean;
+    retentionScopes: VoiceDataRetentionScope[];
+    selfHostedConfiguredStorage: string[];
+    zeroRetentionAvailable: boolean;
+};
+export type VoiceDataControlRoutesOptions = VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditActor?: VoiceAuditActor;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    providerKeys?: VoiceDataControlProviderKeySurface[];
+    redact?: import('./trace').VoiceTraceRedactionConfig | boolean;
+    title?: string;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+};
+export declare const applyVoiceDataRetentionPolicy: (options: VoiceDataRetentionPolicy) => Promise<VoiceDataRetentionReport>;
+export declare const buildVoiceDataRetentionPlan: (options: Omit<VoiceDataRetentionPolicy, "dryRun">) => Promise<VoiceDataRetentionReport>;
+export declare const evaluateVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
+export declare const assertVoiceDataControlEvidence: (report: VoiceDataControlReport, input?: VoiceDataControlAssertionInput) => VoiceDataControlAssertionReport;
+export declare const createVoiceZeroRetentionPolicy: (options: VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditActor?: VoiceAuditActor;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    scopes?: VoiceDataRetentionScope[];
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+}) => VoiceDataRetentionPolicy;
+export declare const buildVoiceDataControlReport: (options: VoiceDataControlRoutesOptions & {
+    auditFilter?: VoiceAuditEventFilter;
+    retention?: Omit<VoiceDataRetentionPolicy, "dryRun">;
+}) => Promise<VoiceDataControlReport>;
+export declare const renderVoiceDataControlHTML: (report: VoiceDataControlReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceDataControlMarkdown: (report: VoiceDataControlReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceDataControlRoutes: (options: VoiceDataControlRoutesOptions) => 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/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

@@ -5,6 +5,7 @@ export type VoiceEvalStatus = 'pass' | 'fail';
 export type VoiceEvalSessionReport = {
     endedAt?: number;
     eventCount: number;
+    operationsRecordHref?: string;
     quality: VoiceQualityReport;
     scenarioId?: string;
     sessionId: string;
@@ -59,6 +60,75 @@ 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;
@@ -68,11 +138,15 @@ export type VoiceEvalRoutesOptions = {
     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;
@@ -80,11 +154,25 @@ 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;
 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;
@@ -93,6 +181,14 @@ export declare const renderVoiceEvalBaselineHTML: (comparison: VoiceEvalBaseline
     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: {};