@absolutejs/voice 0.0.22-beta.25 → 0.0.22-beta.250

package/dist/client/traceTimeline.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceTraceTimelineReport } from '../traceTimeline';
+export type VoiceTraceTimelineClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceTraceTimelineSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceTraceTimelineReport | null;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTraceTimeline: (path?: string, options?: Pick<VoiceTraceTimelineClientOptions, "fetch">) => Promise<VoiceTraceTimelineReport>;
+export declare const createVoiceTraceTimelineStore: (path?: string, options?: VoiceTraceTimelineClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTraceTimelineSnapshot;
+    getSnapshot: () => VoiceTraceTimelineSnapshot;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/traceTimelineWidget.d.ts

@@ -0,0 +1,36 @@
+import type { VoiceTraceTimelineSession } from '../traceTimeline';
+import { type VoiceTraceTimelineClientOptions, type VoiceTraceTimelineSnapshot } from './traceTimeline';
+export type VoiceTraceTimelineSessionView = VoiceTraceTimelineSession & {
+    detailHref: string;
+    durationLabel: string;
+    incidentBundleHref?: string;
+    label: string;
+    operationsRecordHref?: string;
+    providerLabel: string;
+};
+export type VoiceTraceTimelineViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    sessions: VoiceTraceTimelineSessionView[];
+    status: 'empty' | 'error' | 'failed' | 'loading' | 'ready' | 'warning';
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceTraceTimelineWidgetOptions = VoiceTraceTimelineClientOptions & {
+    description?: string;
+    detailBasePath?: string;
+    incidentBundleBasePath?: false | string;
+    limit?: number;
+    operationsRecordBasePath?: false | string;
+    title?: string;
+};
+export declare const createVoiceTraceTimelineViewModel: (snapshot: VoiceTraceTimelineSnapshot, options?: VoiceTraceTimelineWidgetOptions) => VoiceTraceTimelineViewModel;
+export declare const renderVoiceTraceTimelineWidgetHTML: (snapshot: VoiceTraceTimelineSnapshot, options?: VoiceTraceTimelineWidgetOptions) => string;
+export declare const getVoiceTraceTimelineCSS: () => string;
+export declare const mountVoiceTraceTimeline: (element: Element, path?: string, options?: VoiceTraceTimelineWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+};
+export declare const defineVoiceTraceTimelineElement: (tagName?: string) => void;

package/dist/client/turnLatency.d.ts

@@ -0,0 +1,22 @@
+import type { VoiceTurnLatencyReport } from '../turnLatency';
+export type VoiceTurnLatencyClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    proofPath?: string;
+};
+export type VoiceTurnLatencySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceTurnLatencyReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTurnLatency: (path?: string, options?: Pick<VoiceTurnLatencyClientOptions, "fetch">) => Promise<VoiceTurnLatencyReport>;
+export declare const runVoiceTurnLatencyProof: (path: string, options?: Pick<VoiceTurnLatencyClientOptions, "fetch">) => Promise<unknown>;
+export declare const createVoiceTurnLatencyStore: (path?: string, options?: VoiceTurnLatencyClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTurnLatencySnapshot;
+    getSnapshot: () => VoiceTurnLatencySnapshot;
+    refresh: () => Promise<VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<VoiceTurnLatencyReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/turnLatencyWidget.d.ts

@@ -0,0 +1,33 @@
+import type { VoiceTurnLatencyItem } from '../turnLatency';
+import { type VoiceTurnLatencyClientOptions, type VoiceTurnLatencySnapshot } from './turnLatency';
+export type VoiceTurnLatencyCardView = VoiceTurnLatencyItem & {
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceTurnLatencyViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    proofLabel?: string;
+    showProofAction: boolean;
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    turns: VoiceTurnLatencyCardView[];
+    updatedAt?: number;
+};
+export type VoiceTurnLatencyWidgetOptions = VoiceTurnLatencyClientOptions & {
+    description?: string;
+    proofLabel?: string;
+    title?: string;
+};
+export declare const createVoiceTurnLatencyViewModel: (snapshot: VoiceTurnLatencySnapshot, options?: VoiceTurnLatencyWidgetOptions) => VoiceTurnLatencyViewModel;
+export declare const renderVoiceTurnLatencyHTML: (snapshot: VoiceTurnLatencySnapshot, options?: VoiceTurnLatencyWidgetOptions) => string;
+export declare const mountVoiceTurnLatency: (element: Element, path?: string, options?: VoiceTurnLatencyWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+};
+export declare const defineVoiceTurnLatencyElement: (tagName?: string) => void;

package/dist/client/turnQuality.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export type VoiceTurnQualityClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceTurnQualitySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceTurnQualityReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTurnQuality: (path?: string, options?: Pick<VoiceTurnQualityClientOptions, "fetch">) => Promise<VoiceTurnQualityReport>;
+export declare const createVoiceTurnQualityStore: (path?: string, options?: VoiceTurnQualityClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTurnQualitySnapshot;
+    getSnapshot: () => VoiceTurnQualitySnapshot;
+    refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/turnQualityWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceTurnQualityItem } from '../turnQuality';
+import { type VoiceTurnQualityClientOptions, type VoiceTurnQualitySnapshot } from './turnQuality';
+export type VoiceTurnQualityCardView = VoiceTurnQualityItem & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceTurnQualityViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    turns: VoiceTurnQualityCardView[];
+    updatedAt?: number;
+};
+export type VoiceTurnQualityWidgetOptions = VoiceTurnQualityClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceTurnQualityViewModel: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => VoiceTurnQualityViewModel;
+export declare const renderVoiceTurnQualityHTML: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => string;
+export declare const getVoiceTurnQualityCSS: () => string;
+export declare const mountVoiceTurnQuality: (element: Element, path?: string, options?: VoiceTurnQualityWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTurnQualityReport | undefined>;
+};
+export declare const defineVoiceTurnQualityElement: (tagName?: string) => void;

package/dist/client/workflowStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export type VoiceWorkflowStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceWorkflowStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceScenarioEvalReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceWorkflowStatus: (path?: string, options?: Pick<VoiceWorkflowStatusClientOptions, "fetch">) => Promise<VoiceScenarioEvalReport>;
+export declare const createVoiceWorkflowStatusStore: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceWorkflowStatusSnapshot;
+    getSnapshot: () => VoiceWorkflowStatusSnapshot;
+    refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/dataControl.d.ts

@@ -0,0 +1,140 @@
+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 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 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: {};
+}>;